SVF::LLVMUtil Namespace Reference

Functions
bool	isCallSite (const Instruction *inst)
	Whether an instruction is a call or invoke instruction.
bool	isCallSite (const Value *val)
	Whether an instruction is a call or invoke instruction.
double	getDoubleValue (const ConstantFP *fpValue)
std::pair< s64_t, u64_t >	getIntegerValue (const ConstantInt *intValue)
const CallBase *	getLLVMCallSite (const Value *value)
	Return LLVM callsite given a value.
const Function *	getCallee (const CallBase *cs)
const Function *	getLLVMFunction (const Value *val)
	Return LLVM function if this value is.
const Function *	getProgFunction (const std::string &funName)
	Get program entry function from module.
bool	isProgEntryFunction (const Function *fun)
	Check whether a function is an entry function (i.e., main)
bool	isBlackholeSym (const Value *val)
	Check whether this value is a black hole.
bool	isNullPtrSym (const Value *val)
	Check whether this value is a black hole.
static Type *	getPtrElementType (const PointerType *pty)
u32_t	getNumOfElements (const Type *ety)
	Return size of this object based on LLVM value.
bool	isObject (const Value *ref)
	Return true if this value refers to a object.
bool	isUncalledFunction (const Function *fun)
	whether this is a function without any possible caller?
bool	ArgInDeadFunction (const Value *val)
	whether this is an argument in dead function
bool	ArgInProgEntryFunction (const Value *val)
	Return true if this is an argument of a program entry function (e.g. main)
bool	isPtrInUncalledFunction (const Value *value)
	Return true if this is value in a dead function (function without any caller)
bool	isNoCallerFunction (const Function *fun)
	Function does not have any possible caller in the call graph.
bool	isArgOfUncalledFunction (const Value *val)
	Return true if the argument in a function does not have a caller.
bool	basicBlockHasRetInst (const BasicBlock *bb)
	Return true if the function has a return instruction.
bool	functionDoesNotRet (const Function *fun)
void	getFunReachableBBs (const Function *svfFun, std::vector< const SVFBasicBlock * > &bbs)
	Get reachable basic block from function entry.
const Value *	stripConstantCasts (const Value *val)
	Strip off the constant casts.
const Value *	stripAllCasts (const Value *val)
	Strip off the all casts.
const Value *	getFirstUseViaCastInst (const Value *val)
const ConstantExpr *	isGepConstantExpr (const Value *val)
	Return corresponding constant expression, otherwise return nullptr.
const ConstantExpr *	isInt2PtrConstantExpr (const Value *val)
const ConstantExpr *	isPtr2IntConstantExpr (const Value *val)
const ConstantExpr *	isCastConstantExpr (const Value *val)
const ConstantExpr *	isSelectConstantExpr (const Value *val)
const ConstantExpr *	isTruncConstantExpr (const Value *val)
const ConstantExpr *	isCmpConstantExpr (const Value *val)
const ConstantExpr *	isBinaryConstantExpr (const Value *val)
const ConstantExpr *	isUnaryConstantExpr (const Value *val)
static DataLayout *	getDataLayout (Module *mod)
void	getNextInsts (const Instruction *curInst, std::vector< const Instruction * > &instList)
	Get the next instructions following control flow.
bool	isNoPrecessorBasicBlock (const BasicBlock *bb)
bool	isIRFile (const std::string &filename)
	Check whether a file is an LLVM IR file.
void	processArguments (int argc, char **argv, int &arg_num, char **arg_value, std::vector< std::string > &moduleNameVec)
	Parse argument for multi-module analysis.
const std::string	getSourceLoc (const Value *val)
const std::string	getSourceLocOfFunction (const Function *F)
bool	isIntrinsicInst (const Instruction *inst)
	Return true if it is an intrinsic instruction.
bool	isIntrinsicFun (const Function *func)
std::vector< const Function * >	getCalledFunctions (const Function *F)
	Get all called funcions in a parent function.
std::string	restoreFuncName (std::string funcName)
bool	isExtCall (const Function *fun)
bool	isMemcpyExtFun (const Function *fun)
bool	isMemsetExtFun (const Function *fun)
u32_t	getHeapAllocHoldingArgPosition (const Function *fun)
const FunObjVar *	getFunObjVar (const std::string &name)
bool	isConstDataOrAggData (const Value *val)
	Return true if the value refers to constant data, e.g., i32 0.
const Value *	getGlobalRep (const Value *val)
	find the unique defined global across multiple modules
bool	isConstantObjSym (const Value *val)
	Check whether this value points-to a constant object.
void	viewCFG (const Function *fun)
void	viewCFGOnly (const Function *fun)
std::string	dumpValue (const Value *val)
std::string	dumpType (const Type *type)
std::string	dumpValueAndDbgInfo (const Value *val)
bool	isHeapAllocExtCallViaRet (const Instruction *inst)
bool	isHeapAllocExtCallViaArg (const Instruction *inst)
bool	isHeapAllocExtCall (const Instruction *inst)
bool	isStackAllocExtCallViaRet (const Instruction *inst)
bool	isStackAllocExtCall (const Instruction *inst)
bool	isHeapObj (const Value *val)
bool	isStackObj (const Value *val)
bool	isNonInstricCallSite (const Instruction *inst)
	Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls.
const Function *	getProgEntryFunction (Module &module)
	Get program entry function from module.

Function Documentation

ArgInDeadFunction()

bool SVF::LLVMUtil::ArgInDeadFunction ( const Value *  val )

inline

whether this is an argument in dead function

Definition at line 162 of file LLVMUtil.h.

{
    return SVFUtil::isa<Argument>(val)
           && isUncalledFunction(SVFUtil::cast<Argument>(val)->getParent());
}

ArgInProgEntryFunction()

bool SVF::LLVMUtil::ArgInProgEntryFunction ( const Value *  val )

inline

Return true if this is an argument of a program entry function (e.g. main)

Definition at line 170 of file LLVMUtil.h.

{
    return SVFUtil::isa<Argument>(val) &&
           LLVMUtil::isProgEntryFunction(
               SVFUtil::cast<Argument>(val)->getParent());
}

basicBlockHasRetInst()

bool SVF::LLVMUtil::basicBlockHasRetInst

(

const BasicBlock *

bb

)

Return true if the function has a return instruction.

Return true if the basic block has a return instruction

Definition at line 110 of file LLVMUtil.cpp.

{
    for (BasicBlock::const_iterator it = bb->begin(), eit = bb->end();
            it != eit; ++it)
    {
        if(SVFUtil::isa<ReturnInst>(*it))
            return true;
    }
    return false;
}

dumpType()

std::string SVF::LLVMUtil::dumpType

(

const Type *

type

)

Definition at line 627 of file LLVMUtil.cpp.

{
    std::string str;
    llvm::raw_string_ostream rawstr(str);
    if (type)
        rawstr << " " << *type << " ";
    else
        rawstr << " llvm type is null";
    return rawstr.str();
}

dumpValue()

std::string SVF::LLVMUtil::dumpValue

(

const Value *

val

)

Definition at line 616 of file LLVMUtil.cpp.

{
    std::string str;
    llvm::raw_string_ostream rawstr(str);
    if (val)
        rawstr << " " << *val << " ";
    else
        rawstr << " llvm Value is null";
    return rawstr.str();
}

dumpValueAndDbgInfo()

std::string SVF::LLVMUtil::dumpValueAndDbgInfo

(

const Value *

val

)

Definition at line 638 of file LLVMUtil.cpp.

{
    std::string str;
    llvm::raw_string_ostream rawstr(str);
    if (val)
        rawstr << dumpValue(val) << getSourceLoc(val);
    else
        rawstr << " llvm Value is null";
    return rawstr.str();
}

functionDoesNotRet()

bool SVF::LLVMUtil::functionDoesNotRet

(

const Function *

fun

)

Return true if the function has a return instruction reachable from function entry

Definition at line 124 of file LLVMUtil.cpp.

{
    if (LLVMUtil::isExtCall(fun))
    {
        return fun->getReturnType()->isVoidTy();
    }
    std::vector<const BasicBlock*> bbVec;
    Set<const BasicBlock*> visited;
    bbVec.push_back(&fun->getEntryBlock());
    while(!bbVec.empty())
    {
        const BasicBlock* bb = bbVec.back();
        bbVec.pop_back();
        if (basicBlockHasRetInst(bb))
        {
            return false;
        }
 
        for (succ_const_iterator sit = succ_begin(bb), esit = succ_end(bb);
                sit != esit; ++sit)
        {
            const BasicBlock* succbb = (*sit);
            if(visited.find(succbb)==visited.end())
                visited.insert(succbb);
            else
                continue;
            bbVec.push_back(succbb);
        }
    }
    return true;
}

getCalledFunctions()

std::vector< const Function * > SVF::LLVMUtil::getCalledFunctions

(

const Function *

F

)

Get all called funcions in a parent function.

Definition at line 365 of file LLVMUtil.cpp.

{
    std::vector<const Function *> calledFunctions;
    for (const Instruction &I : instructions(F))
    {
        if (const CallBase *callInst = SVFUtil::dyn_cast<CallBase>(&I))
        {
            Function *calledFunction = callInst->getCalledFunction();
            if (calledFunction)
            {
                calledFunctions.push_back(calledFunction);
                std::vector<const Function *> nestedCalledFunctions = getCalledFunctions(calledFunction);
                calledFunctions.insert(calledFunctions.end(), nestedCalledFunctions.begin(), nestedCalledFunctions.end());
            }
        }
    }
    return calledFunctions;
}

getCallee()

const Function * SVF::LLVMUtil::getCallee ( const CallBase *  cs )

inline

Definition at line 100 of file LLVMUtil.h.

{
    // FIXME: do we need to strip-off the casts here to discover more library functions
    return SVFUtil::dyn_cast<Function>(cs->getCalledOperand()->stripPointerCasts());
}

getDataLayout()

static DataLayout * SVF::LLVMUtil::getDataLayout ( Module *  mod )

inlinestatic

Definition at line 319 of file LLVMUtil.h.

{
    static DataLayout *dl = nullptr;
    if (dl == nullptr)
#if LLVM_VERSION_MAJOR >= 19
        dl = new DataLayout(mod->getDataLayout());
#else
        dl = new DataLayout(mod);
#endif
    return dl;
}

getDoubleValue()

double SVF::LLVMUtil::getDoubleValue ( const ConstantFP *  fpValue )

inline

Definition at line 57 of file LLVMUtil.h.

{
    double dval = 0;
    if (fpValue->isNormalFP())
    {
        const llvm::fltSemantics& semantics = fpValue->getValueAPF().getSemantics();
        if (&semantics == &llvm::APFloat::IEEEhalf() ||
                &semantics == &llvm::APFloat::IEEEsingle() ||
                &semantics == &llvm::APFloat::IEEEdouble() ||
                &semantics == &llvm::APFloat::IEEEquad() ||
                &semantics == &llvm::APFloat::x87DoubleExtended())
        {
            dval = fpValue->getValueAPF().convertToDouble();
        }
        else
        {
            assert (false && "Unsupported floating point type");
            abort();
        }
    }
    else
    {
        // other cfp type, like isZero(), isInfinity(), isNegative(), etc.
        // do nothing
    }
    return dval;
}

getFirstUseViaCastInst()

const Value * SVF::LLVMUtil::getFirstUseViaCastInst

(

const Value *

val

)

Return the bitcast instruction right next to val, otherwise return nullptr

If type is void* (i8*) and val is immediately used at a bitcast instruction

Definition at line 279 of file LLVMUtil.cpp.

{
    assert(SVFUtil::isa<PointerType>(val->getType()) && "this value should be a pointer type!");
    const Value *latestUse = nullptr;
    for (const auto &it : val->uses())
    {
        if (SVFUtil::isa<BitCastInst>(it.getUser()))
            latestUse = it.getUser();
        else
            latestUse = nullptr;
    }
    return latestUse;
}

getFunObjVar()

const FunObjVar * SVF::LLVMUtil::getFunObjVar

(

const std::string &

name

)

Definition at line 437 of file LLVMUtil.cpp.

{
    return LLVMModuleSet::getLLVMModuleSet()->getFunObjVar(name);
}

getFunReachableBBs()

void SVF::LLVMUtil::getFunReachableBBs	(	const Function *	fun,
		std::vector< const SVFBasicBlock * > &	reachableBBs
	)

Get reachable basic block from function entry.

Return reachable bbs from function entry

Definition at line 76 of file LLVMUtil.cpp.

{
    assert(!LLVMUtil::isExtCall(fun) && "The calling function cannot be an external function.");
    //initial DominatorTree
    DominatorTree& dt = LLVMModuleSet::getLLVMModuleSet()->getDomTree(fun);
 
    Set<const BasicBlock*> visited;
    std::vector<const BasicBlock*> bbVec;
    bbVec.push_back(&fun->getEntryBlock());
    while(!bbVec.empty())
    {
        const BasicBlock* bb = bbVec.back();
        bbVec.pop_back();
        const SVFBasicBlock* svfbb = LLVMModuleSet::getLLVMModuleSet()->getSVFBasicBlock(bb);
        reachableBBs.push_back(svfbb);
        if(DomTreeNode *dtNode = dt.getNode(const_cast<BasicBlock*>(bb)))
        {
            for (DomTreeNode::iterator DI = dtNode->begin(), DE = dtNode->end();
                    DI != DE; ++DI)
            {
                const BasicBlock* succbb = (*DI)->getBlock();
                if(visited.find(succbb)==visited.end())
                    visited.insert(succbb);
                else
                    continue;
                bbVec.push_back(succbb);
            }
        }
    }
}

getGlobalRep()

const Value * SVF::LLVMUtil::getGlobalRep

(

const Value *

val

)

find the unique defined global across multiple modules

Definition at line 441 of file LLVMUtil.cpp.

{
    if (const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
    {
        if (LLVMModuleSet::getLLVMModuleSet()->hasGlobalRep(gvar))
            val = LLVMModuleSet::getLLVMModuleSet()->getGlobalRep(gvar);
    }
    return val;
}

getHeapAllocHoldingArgPosition()

u32_t SVF::LLVMUtil::getHeapAllocHoldingArgPosition

(

const Function *

fun

)

Definition at line 402 of file LLVMUtil.cpp.

{
    return LLVMModuleSet::getLLVMModuleSet()->get_alloc_arg_pos(fun);
}

getIntegerValue()

std::pair< s64_t, u64_t > SVF::LLVMUtil::getIntegerValue ( const ConstantInt *  intValue )

inline

Definition at line 85 of file LLVMUtil.h.

{
    if (intValue->getBitWidth() <= 64 && intValue->getBitWidth() >= 1)
        return std::make_pair(intValue->getSExtValue(), intValue->getZExtValue());
    else
        return std::make_pair(0,0);
}

getLLVMCallSite()

const CallBase * SVF::LLVMUtil::getLLVMCallSite ( const Value *  value )

inline

Return LLVM callsite given a value.

Definition at line 94 of file LLVMUtil.h.

{
    assert(isCallSite(value) && "not a callsite?");
    return SVFUtil::cast<CallBase>(value);
}

getLLVMFunction()

const Function * SVF::LLVMUtil::getLLVMFunction ( const Value *  val )

inline

Return LLVM function if this value is.

Definition at line 107 of file LLVMUtil.h.

{
    return SVFUtil::dyn_cast<Function>(val->stripPointerCasts());
}

getNextInsts()

void SVF::LLVMUtil::getNextInsts	(	const Instruction *	curInst,
		std::vector< const Instruction * > &	instList
	)

Get the next instructions following control flow.

Definition at line 589 of file LLVMUtil.cpp.

{
    if (!curInst->isTerminator())
    {
        const Instruction* nextInst = curInst->getNextNode();
        if (LLVMUtil::isIntrinsicInst(nextInst))
            getNextInsts(nextInst, instList);
        else
            instList.push_back(nextInst);
    }
    else
    {
        const BasicBlock *BB = curInst->getParent();
        // Visit all successors of BB in the CFG
        for (succ_const_iterator it = succ_begin(BB), ie = succ_end(BB); it != ie; ++it)
        {
            const Instruction* nextInst = &((*it)->front());
            if (LLVMUtil::isIntrinsicInst(nextInst))
                getNextInsts(nextInst, instList);
            else
                instList.push_back(nextInst);
        }
    }
}

getNumOfElements()

u32_t SVF::LLVMUtil::getNumOfElements

(

const Type *

ety

)

Return size of this object based on LLVM value.

Return size of this Object

Definition at line 297 of file LLVMUtil.cpp.

{
    assert(ety && "type is null?");
    u32_t numOfFields = 1;
    if (SVFUtil::isa<StructType, ArrayType>(ety))
    {
        if(Options::ModelArrays())
            return LLVMModuleSet::getLLVMModuleSet()->getSVFType(ety)->getTypeInfo()->getNumOfFlattenElements();
        else
            return LLVMModuleSet::getLLVMModuleSet()->getSVFType(ety)->getTypeInfo()->getNumOfFlattenFields();
    }
    return numOfFields;
}

getProgEntryFunction()

const Function * SVF::LLVMUtil::getProgEntryFunction ( Module &  module )

inline

Get program entry function from module.

Definition at line 428 of file LLVMUtil.h.

{
    for (auto it = module.begin(), eit = module.end(); it != eit; ++it)
    {
        const Function *fun = &(*it);
        if (isProgEntryFunction(fun))
            return (fun);
    }
    return nullptr;
}

getProgFunction()

const Function * SVF::LLVMUtil::getProgFunction

(

const std::string &

funName

)

Get program entry function from module.

Definition at line 41 of file LLVMUtil.cpp.

{
    for (const Module& M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
    {
        for (const Function& fun : M)
        {
            if (fun.getName() == funName)
                return &fun;
        }
    }
    return nullptr;
}

getPtrElementType()

static Type * SVF::LLVMUtil::getPtrElementType ( const PointerType *  pty )

inlinestatic

Definition at line 134 of file LLVMUtil.h.

{
#if (LLVM_VERSION_MAJOR < 14)
    return pty->getPointerElementType();
#elif (LLVM_VERSION_MAJOR < 17)
    assert(!pty->isOpaque() && "Opaque Pointer is used, please recompile the source adding '-Xclang -no-opaque-pointers'");
    return pty->getNonOpaquePointerElementType();
#else
    (void)pty; // Suppress warning of unused variable under release build
    assert(false && "llvm version 17+ only support opaque pointers!");
    return nullptr;
#endif
}

getSourceLoc()

const std::string SVF::LLVMUtil::getSourceLoc

(

const Value *

val

)

Get the meta data (line number and file name) info of a LLVM value

Definition at line 454 of file LLVMUtil.cpp.

{
    if(val==nullptr)  return "{ empty val }";
 
    std::string str;
    std::stringstream rawstr(str);
    rawstr << "{ ";
 
    if (const Instruction* inst = SVFUtil::dyn_cast<Instruction>(val))
    {
        if (SVFUtil::isa<AllocaInst>(inst))
        {
#if LLVM_VERSION_MAJOR >= 20
            for (llvm::DbgVariableRecord *DVR : llvm::findDVRDeclares(const_cast<Instruction*>(inst)))
            {
                llvm::DIVariable *DIVar = DVR->getVariable();
                rawstr << "\"ln\": " << DIVar->getLine() << ", \"fl\": \"" << DIVar->getFilename().str() << "\"";
                break;
            }
#else
#if LLVM_VERSION_MAJOR > 16
            for (llvm::DbgInfoIntrinsic *DII : llvm::findDbgDeclares(const_cast<Instruction*>(inst)))
#else
            for (llvm::DbgInfoIntrinsic *DII : FindDbgDeclareUses(const_cast<Instruction*>(inst)))
#endif
            {
                if (llvm::DbgDeclareInst *DDI = SVFUtil::dyn_cast<llvm::DbgDeclareInst>(DII))
                {
                    llvm::DIVariable *DIVar = SVFUtil::cast<llvm::DIVariable>(DDI->getVariable());
                    rawstr << "\"ln\": " << DIVar->getLine() << ", \"fl\": \"" << DIVar->getFilename().str() << "\"";
                    break;
                }
            }
#endif
        }
        else if (MDNode *N = inst->getMetadata("dbg"))   // Here I is an LLVM instruction
        {
            llvm::DILocation* Loc = SVFUtil::cast<llvm::DILocation>(N);                   // DILocation is in DebugInfo.h
            unsigned Line = Loc->getLine();
            unsigned Column = Loc->getColumn();
            std::string File = Loc->getFilename().str();
            //StringRef Dir = Loc.getDirectory();
            if(File.empty() || Line == 0)
            {
                auto inlineLoc = Loc->getInlinedAt();
                if(inlineLoc)
                {
                    Line = inlineLoc->getLine();
                    Column = inlineLoc->getColumn();
                    File = inlineLoc->getFilename().str();
                }
            }
            rawstr << "\"ln\": " << Line << ", \"cl\": " << Column << ", \"fl\": \"" << File << "\"";
        }
    }
    else if (const Argument* argument = SVFUtil::dyn_cast<Argument>(val))
    {
        if (argument->getArgNo()%10 == 1)
            rawstr << argument->getArgNo() << "st";
        else if (argument->getArgNo()%10 == 2)
            rawstr << argument->getArgNo() << "nd";
        else if (argument->getArgNo()%10 == 3)
            rawstr << argument->getArgNo() << "rd";
        else
            rawstr << argument->getArgNo() << "th";
        rawstr << " arg " << argument->getParent()->getName().str() << " "
               << getSourceLocOfFunction(argument->getParent());
    }
    else if (const GlobalVariable* gvar = SVFUtil::dyn_cast<GlobalVariable>(val))
    {
        rawstr << "Glob ";
        NamedMDNode* CU_Nodes = gvar->getParent()->getNamedMetadata("llvm.dbg.cu");
        if(CU_Nodes)
        {
            for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i)
            {
                llvm::DICompileUnit *CUNode = SVFUtil::cast<llvm::DICompileUnit>(CU_Nodes->getOperand(i));
                for (llvm::DIGlobalVariableExpression *GV : CUNode->getGlobalVariables())
                {
                    llvm::DIGlobalVariable * DGV = GV->getVariable();
 
                    if(DGV->getName() == gvar->getName())
                    {
                        rawstr << "\"ln\": " << DGV->getLine() << ", \"fl\": \"" << DGV->getFilename().str() << "\"";
                    }
 
                }
            }
        }
    }
    else if (const Function* func = SVFUtil::dyn_cast<Function>(val))
    {
        rawstr << getSourceLocOfFunction(func);
    }
    else if (const BasicBlock* bb = SVFUtil::dyn_cast<BasicBlock>(val))
    {
        auto nonPhiIt = bb->getFirstNonPHIIt();
        rawstr << "\"basic block\": " << bb->getName().str() << ", \"location\": " << getSourceLoc(nonPhiIt != bb->end() ? &*nonPhiIt : nullptr);
    }
    else if(LLVMUtil::isConstDataOrAggData(val))
    {
        rawstr << "constant data";
    }
    else
    {
        rawstr << "N/A";
    }
    rawstr << " }";
 
    if(rawstr.str()=="{  }")
        return "";
    return rawstr.str();
}

getSourceLocOfFunction()

const std::string SVF::LLVMUtil::getSourceLocOfFunction

(

const Function *

F

)

Get source code line number of a function according to debug info

Definition at line 572 of file LLVMUtil.cpp.

{
    std::string str;
    std::stringstream rawstr(str);
    /*
     * https://reviews.llvm.org/D18074?id=50385
     * looks like the relevant
     */
    if (llvm::DISubprogram *SP =  F->getSubprogram())
    {
        if (SP->describes(F))
            rawstr << "\"ln\": " << SP->getLine() << ", \"file\": \"" << SP->getFilename().str() << "\"";
    }
    return rawstr.str();
}

isArgOfUncalledFunction()

bool SVF::LLVMUtil::isArgOfUncalledFunction ( const Value *  val )

inline

Return true if the argument in a function does not have a caller.

Definition at line 191 of file LLVMUtil.h.

{
    return SVFUtil::isa<Argument>(val)
           && isNoCallerFunction(SVFUtil::cast<Argument>(val)->getParent());
}

isBinaryConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isBinaryConstantExpr ( const Value *  val )

inline

Definition at line 296 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if ((constExpr->getOpcode() >= Instruction::BinaryOpsBegin) &&
                (constExpr->getOpcode() <= Instruction::BinaryOpsEnd))
            return constExpr;
    }
    return nullptr;
}

isBlackholeSym()

bool SVF::LLVMUtil::isBlackholeSym ( const Value *  val )

inline

Check whether this value is a black hole.

Definition at line 123 of file LLVMUtil.h.

{
    return SVFUtil::isa<UndefValue>(val);
}

isCallSite() [1/2]

bool SVF::LLVMUtil::isCallSite ( const Instruction *  inst )

inline

Whether an instruction is a call or invoke instruction.

Definition at line 47 of file LLVMUtil.h.

{
    return SVFUtil::isa<CallBase>(inst);
}

isCallSite() [2/2]

bool SVF::LLVMUtil::isCallSite ( const Value *  val )

inline

Whether an instruction is a call or invoke instruction.

Definition at line 52 of file LLVMUtil.h.

{
    return SVFUtil::isa<CallBase>(val);
}

isCastConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isCastConstantExpr ( const Value *  val )

inline

Definition at line 251 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::BitCast)
            return constExpr;
    }
    return nullptr;
}

isCmpConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isCmpConstantExpr ( const Value *  val )

inline

Definition at line 285 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::ICmp ||
                constExpr->getOpcode() == Instruction::FCmp)
            return constExpr;
    }
    return nullptr;
}

isConstantObjSym()

bool SVF::LLVMUtil::isConstantObjSym

(

const Value *

val

)

Check whether this value points-to a constant object.

Check whether this value points-to a constant object

Definition at line 747 of file CppUtil.cpp.

{
    if (const GlobalVariable* v = SVFUtil::dyn_cast<GlobalVariable>(val))
    {
        if (cppUtil::isValVtbl(v))
            return false;
        else if (!v->hasInitializer())
        {
            return !v->isExternalLinkage(v->getLinkage());
        }
        else
        {
            StInfo *stInfo = LLVMModuleSet::getLLVMModuleSet()->getSVFType(v->getInitializer()->getType())->getTypeInfo();
            const std::vector<const SVFType*> &fields = stInfo->getFlattenFieldTypes();
            for (std::vector<const SVFType*>::const_iterator it = fields.begin(), eit = fields.end(); it != eit; ++it)
            {
                const SVFType* elemTy = *it;
                assert(!SVFUtil::isa<SVFFunctionType>(elemTy) && "Initializer of a global is a function?");
                if (SVFUtil::isa<SVFPointerType>(elemTy))
                    return false;
            }
 
            return v->isConstant();
        }
    }
    return LLVMUtil::isConstDataOrAggData(val);
}

isConstDataOrAggData()

bool SVF::LLVMUtil::isConstDataOrAggData ( const Value *  val )

inline

Return true if the value refers to constant data, e.g., i32 0.

Definition at line 378 of file LLVMUtil.h.

{
    return SVFUtil::isa<ConstantData, ConstantAggregate,
           MetadataAsValue, BlockAddress>(val);
}

isExtCall()

bool SVF::LLVMUtil::isExtCall

(

const Function *

fun

)

Definition at line 385 of file LLVMUtil.cpp.

{
    return fun && LLVMModuleSet::getLLVMModuleSet()->is_ext(fun);
}

isGepConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isGepConstantExpr ( const Value *  val )

inline

Return corresponding constant expression, otherwise return nullptr.

Definition at line 221 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::GetElementPtr)
            return constExpr;
    }
    return nullptr;
}

isHeapAllocExtCall()

bool SVF::LLVMUtil::isHeapAllocExtCall ( const Instruction *  inst )

inline

Definition at line 406 of file LLVMUtil.h.

{
    return isHeapAllocExtCallViaRet(inst) || isHeapAllocExtCallViaArg(inst);
}

isHeapAllocExtCallViaArg()

bool SVF::LLVMUtil::isHeapAllocExtCallViaArg

(

const Instruction *

inst

)

Definition at line 664 of file LLVMUtil.cpp.

{
    if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
    {
        const Function* fun = call->getCalledFunction();
        return fun &&
               LLVMModuleSet::getLLVMModuleSet()->is_arg_alloc(fun);
    }
    else
    {
        return false;
    }
}

isHeapAllocExtCallViaRet()

bool SVF::LLVMUtil::isHeapAllocExtCallViaRet

(

const Instruction *

inst

)

Definition at line 649 of file LLVMUtil.cpp.

{
    LLVMModuleSet* pSet = LLVMModuleSet::getLLVMModuleSet();
    bool isPtrTy = inst->getType()->isPointerTy();
    if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
    {
        const Function* fun = call->getCalledFunction();
        return fun && isPtrTy &&
               (pSet->is_alloc(fun) ||
                pSet->is_realloc(fun));
    }
    else
        return false;
}

isHeapObj()

bool SVF::LLVMUtil::isHeapObj

(

const Value *

val

)

Check if a given value represents a heap object.

Parameters

val	The value to check.

Returns

True if the value represents a heap object, false otherwise.

Definition at line 698 of file LLVMUtil.cpp.

{
    // Check if the value is an argument in the program entry function
    if (ArgInProgEntryFunction(val))
    {
        // Return true if the value does not have a first use via cast instruction
        return !getFirstUseViaCastInst(val);
    }
    // Check if the value is an instruction and if it is a heap allocation external call
    else if (SVFUtil::isa<Instruction>(val) &&
             LLVMUtil::isHeapAllocExtCall(SVFUtil::cast<Instruction>(val)))
    {
        return true;
    }
    // Return false if none of the above conditions are met
    return false;
}

isInt2PtrConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isInt2PtrConstantExpr ( const Value *  val )

inline

Definition at line 231 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::IntToPtr)
            return constExpr;
    }
    return nullptr;
}

isIntrinsicFun()

bool SVF::LLVMUtil::isIntrinsicFun

(

const Function *

func

)

Definition at line 191 of file LLVMUtil.cpp.

{
    if (func && (func->getIntrinsicID() == llvm::Intrinsic::donothing ||
                 func->getIntrinsicID() == llvm::Intrinsic::dbg_declare ||
                 func->getIntrinsicID() == llvm::Intrinsic::dbg_label ||
                 func->getIntrinsicID() == llvm::Intrinsic::dbg_value))
    {
        return true;
    }
    return false;
}

isIntrinsicInst()

bool SVF::LLVMUtil::isIntrinsicInst

(

const Instruction *

inst

)

Return true if it is an intrinsic instruction.

Definition at line 204 of file LLVMUtil.cpp.

{
    if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
    {
        const Function* func = call->getCalledFunction();
        if (isIntrinsicFun(func))
        {
            return true;
        }
    }
    return false;
}

isIRFile()

bool SVF::LLVMUtil::isIRFile

(

const std::string &

filename

)

Check whether a file is an LLVM IR file.

Definition at line 316 of file LLVMUtil.cpp.

{
    llvm::LLVMContext context;
    llvm::SMDiagnostic err;
 
    // Parse the input LLVM IR file into a module
    std::unique_ptr<llvm::Module> module = llvm::parseIRFile(filename, err, context);
 
    // Check if the parsing succeeded
    if (!module)
    {
        err.print("isIRFile", llvm::errs());
        return false; // Not an LLVM IR file
    }
 
    return true; // It is an LLVM IR file
}

isMemcpyExtFun()

bool SVF::LLVMUtil::isMemcpyExtFun

(

const Function *

fun

)

Definition at line 390 of file LLVMUtil.cpp.

{
    return fun && LLVMModuleSet::getLLVMModuleSet()->is_memcpy(fun);
}

isMemsetExtFun()

bool SVF::LLVMUtil::isMemsetExtFun

(

const Function *

fun

)

Definition at line 396 of file LLVMUtil.cpp.

{
    return fun && LLVMModuleSet::getLLVMModuleSet()->is_memset(fun);
}

isNoCallerFunction()

bool SVF::LLVMUtil::isNoCallerFunction ( const Function *  fun )

inline

Function does not have any possible caller in the call graph.

Return true if the function does not have a caller (either it is a main function or a dead function)

Definition at line 185 of file LLVMUtil.h.

{
    return isUncalledFunction(fun) || LLVMUtil::isProgEntryFunction(fun);
}

isNonInstricCallSite()

bool SVF::LLVMUtil::isNonInstricCallSite

(

const Instruction *

inst

)

Whether an instruction is a callsite in the application code, excluding llvm intrinsic calls.

Definition at line 736 of file LLVMUtil.cpp.

{
    bool res = false;
 
    if(isIntrinsicInst(inst))
        res = false;
    else
        res = isCallSite(inst);
    return res;
}

isNoPrecessorBasicBlock()

bool SVF::LLVMUtil::isNoPrecessorBasicBlock ( const BasicBlock *  bb )

inline

Basic block does not have predecessors map-1.cpp.bc try.cont: ; No predecessors! call void @llvm.trap() unreachable

Definition at line 341 of file LLVMUtil.h.

{
    return bb != &bb->getParent()->getEntryBlock() &&
           pred_empty(bb);
}

isNullPtrSym()

bool SVF::LLVMUtil::isNullPtrSym ( const Value *  val )

inline

Check whether this value is a black hole.

Definition at line 129 of file LLVMUtil.h.

{
    return SVFUtil::dyn_cast<ConstantPointerNull>(val);
}

isObject()

bool SVF::LLVMUtil::isObject

(

const Value *

ref

)

Return true if this value refers to a object.

A value represents an object if it is 1) function, 2) global 3) stack 4) heap

Definition at line 61 of file LLVMUtil.cpp.

{
    if (SVFUtil::isa<Instruction>(ref) && isHeapAllocExtCallViaRet(SVFUtil::cast<Instruction>(ref)))
        return true;
    if (SVFUtil::isa<GlobalVariable>(ref))
        return true;
    if (SVFUtil::isa<Function, AllocaInst>(ref))
        return true;
 
    return false;
}

isProgEntryFunction()

bool SVF::LLVMUtil::isProgEntryFunction ( const Function *  fun )

inline

Check whether a function is an entry function (i.e., main)

Definition at line 116 of file LLVMUtil.h.

{
    const char* main_name=Options::SVFMain() ? "svf.main" : "main";
    return fun && fun->getName() == main_name;
}

isPtr2IntConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isPtr2IntConstantExpr ( const Value *  val )

inline

Definition at line 241 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::PtrToInt)
            return constExpr;
    }
    return nullptr;
}

isPtrInUncalledFunction()

bool SVF::LLVMUtil::isPtrInUncalledFunction

(

const Value *

value

)

Return true if this is value in a dead function (function without any caller)

Return true if this is a value in a dead function (function without any caller)

Definition at line 176 of file LLVMUtil.cpp.

{
    if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(value))
    {
        if(isUncalledFunction(inst->getParent()->getParent()))
            return true;
    }
    else if(const Argument* arg = SVFUtil::dyn_cast<Argument>(value))
    {
        if(isUncalledFunction(arg->getParent()))
            return true;
    }
    return false;
}

isSelectConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isSelectConstantExpr ( const Value *  val )

inline

Definition at line 261 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::Select)
            return constExpr;
    }
    return nullptr;
}

isStackAllocExtCall()

bool SVF::LLVMUtil::isStackAllocExtCall ( const Instruction *  inst )

inline

Definition at line 413 of file LLVMUtil.h.

{
    return isStackAllocExtCallViaRet(inst);
}

isStackAllocExtCallViaRet()

bool SVF::LLVMUtil::isStackAllocExtCallViaRet

(

const Instruction *

inst

)

Definition at line 678 of file LLVMUtil.cpp.

{
    LLVMModuleSet* pSet = LLVMModuleSet::getLLVMModuleSet();
    bool isPtrTy = inst->getType()->isPointerTy();
    if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
    {
        const Function* fun = call->getCalledFunction();
        return fun && isPtrTy &&
               pSet->is_alloc_stack_ret(fun);
    }
    else
        return false;
}

isStackObj()

bool SVF::LLVMUtil::isStackObj

(

const Value *

val

)

Parameters

val	The value to check.

Returns

True if the value represents a stack object, false otherwise.

Definition at line 720 of file LLVMUtil.cpp.

{
    if (SVFUtil::isa<AllocaInst>(val))
    {
        return true;
    }
    // Check if the value is an instruction and if it is a stack allocation external call
    else if (SVFUtil::isa<Instruction>(val) &&
             LLVMUtil::isStackAllocExtCall(SVFUtil::cast<Instruction>(val)))
    {
        return true;
    }
    // Return false if none of the above conditions are met
    return false;
}

isTruncConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isTruncConstantExpr ( const Value *  val )

inline

Definition at line 271 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (constExpr->getOpcode() == Instruction::Trunc ||
                constExpr->getOpcode() == Instruction::FPTrunc ||
                constExpr->getOpcode() == Instruction::ZExt ||
                constExpr->getOpcode() == Instruction::SExt ||
                constExpr->getOpcode() == Instruction::FPExt)
            return constExpr;
    }
    return nullptr;
}

isUnaryConstantExpr()

const ConstantExpr * SVF::LLVMUtil::isUnaryConstantExpr ( const Value *  val )

inline

Definition at line 307 of file LLVMUtil.h.

{
    if (const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if ((constExpr->getOpcode() >= Instruction::UnaryOpsBegin) &&
                (constExpr->getOpcode() <= Instruction::UnaryOpsEnd))
            return constExpr;
    }
    return nullptr;
}

isUncalledFunction()

bool SVF::LLVMUtil::isUncalledFunction

(

const Function *

fun

)

whether this is a function without any possible caller?

Method for dead function, which does not have any possible caller function address is not taken and never be used in call or invoke instruction

Return true if this is a function without any possible caller

Definition at line 159 of file LLVMUtil.cpp.

{
    if(fun->hasAddressTaken())
        return false;
    if (LLVMUtil::isProgEntryFunction(fun))
        return false;
    for (Value::const_user_iterator i = fun->user_begin(), e = fun->user_end(); i != e; ++i)
    {
        if (LLVMUtil::isCallSite(*i))
            return false;
    }
    return true;
}

processArguments()

void SVF::LLVMUtil::processArguments	(	int	argc,
		char **	argv,
		int &	arg_num,
		char **	arg_value,
		std::vector< std::string > &	moduleNameVec
	)

Parse argument for multi-module analysis.

Get the names of all modules into a vector And process arguments

Definition at line 337 of file LLVMUtil.cpp.

{
    bool first_ir_file = true;
    for (int i = 0; i < argc; ++i)
    {
        std::string argument(argv[i]);
        if (LLVMUtil::isIRFile(argument))
        {
            if (find(moduleNameVec.begin(), moduleNameVec.end(), argument)
                    == moduleNameVec.end())
                moduleNameVec.push_back(argument);
            if (first_ir_file)
            {
                arg_value[arg_num] = argv[i];
                arg_num++;
                first_ir_file = false;
            }
        }
        else
        {
            arg_value[arg_num] = argv[i];
            arg_num++;
        }
    }
}

restoreFuncName()

std::string SVF::LLVMUtil::restoreFuncName

(

std::string

funcName

)

Definition at line 408 of file LLVMUtil.cpp.

{
    assert(!funcName.empty() && "Empty function name");
    // Some function names change due to mangling, such as "fopen" to "\01_fopen" on macOS.
    // Since C function names cannot include '.', change the function name from llvm.memcpy.p0i8.p0i8.i64 to llvm_memcpy_p0i8_p0i8_i64."
    bool hasSpecialPrefix = funcName[0] == '\01';
    bool hasDot = funcName.find('.') != std::string::npos;
 
    if (!hasDot && !hasSpecialPrefix)
        return funcName;
 
    // Remove prefix "\01_" or "\01"
    if (hasSpecialPrefix)
    {
        const std::string prefix1 = "\01_";
        const std::string prefix2 = "\01";
        if (funcName.substr(0, prefix1.length()) == prefix1)
            funcName = funcName.substr(prefix1.length());
        else if (funcName.substr(0, prefix2.length()) == prefix2)
            funcName = funcName.substr(prefix2.length());
    }
    // Replace '.' with '_'
    if (hasDot)
        std::replace(funcName.begin(), funcName.end(), '.', '_');
 
    return funcName;
}

stripAllCasts()

const Value * SVF::LLVMUtil::stripAllCasts

(

const Value *

val

)

Strip off the all casts.

Strip all casts

Definition at line 251 of file LLVMUtil.cpp.

{
    while (true)
    {
        if (const CastInst *ci = SVFUtil::dyn_cast<CastInst>(val))
        {
            val = ci->getOperand(0);
        }
        else if (const ConstantExpr *ce = SVFUtil::dyn_cast<ConstantExpr>(val))
        {
            if(ce->isCast())
                val = ce->getOperand(0);
            else
                return val;
        }
        else
        {
            return val;
        }
    }
    return nullptr;
}

stripConstantCasts()

const Value * SVF::LLVMUtil::stripConstantCasts

(

const Value *

val

)

Strip off the constant casts.

Strip constant casts

Definition at line 220 of file LLVMUtil.cpp.

{
    if (SVFUtil::isa<GlobalValue>(val) || isInt2PtrConstantExpr(val))
        return val;
    else if (const ConstantExpr *CE = SVFUtil::dyn_cast<ConstantExpr>(val))
    {
        if (Instruction::isCast(CE->getOpcode()))
            return stripConstantCasts(CE->getOperand(0));
    }
    return val;
}

viewCFG()

void SVF::LLVMUtil::viewCFG

(

const Function *

fun

)

Definition at line 232 of file LLVMUtil.cpp.

{
    if (fun != nullptr)
    {
        fun->viewCFG();
    }
}

viewCFGOnly()

void SVF::LLVMUtil::viewCFGOnly

(

const Function *

fun

)

Definition at line 240 of file LLVMUtil.cpp.

{
    if (fun != nullptr)
    {
        fun->viewCFGOnly();
    }
}