SVF::LLVMModuleSet Class Reference

#include <LLVMModule.h>

Public Types
typedef std::vector< const Function * >	FunctionSetType
typedef Map< const Function *, const Function * >	FunDeclToDefMapTy
typedef Map< const Function *, FunctionSetType >	FunDefToDeclsMapTy
typedef Map< const GlobalVariable *, GlobalVariable * >	GlobalDefToRepMapTy
typedef Map< const Function *, FunObjVar * >	LLVMFun2FunObjVarMap
typedef Map< const BasicBlock *, SVFBasicBlock * >	LLVMBB2SVFBBMap
typedef Map< const SVFValue *, const Value * >	SVFBaseNode2LLVMValueMap
typedef Map< const Type *, SVFType * >	LLVMType2SVFTypeMap
typedef Map< const Type *, StInfo * >	Type2TypeInfoMap
typedef Map< std::string, std::vector< std::string > >	Fun2AnnoMap
typedef Map< const Instruction *, CallICFGNode * >	CSToCallNodeMapTy
typedef Map< const Instruction *, RetICFGNode * >	CSToRetNodeMapTy
typedef Map< const Instruction *, IntraICFGNode * >	InstToBlockNodeMapTy
typedef Map< const Function *, FunEntryICFGNode * >	FunToFunEntryNodeMapTy
typedef Map< const Function *, FunExitICFGNode * >	FunToFunExitNodeMapTy
typedef OrderedMap< const Value *, NodeID >	ValueToIDMapTy
typedef OrderedMap< const Function *, NodeID >	FunToIDMapTy
typedef std::vector< const Function * >	FunctionSet
typedef Map< const Function *, const BasicBlock * >	FunToExitBBMap
typedef Map< const Function *, const Function * >	FunToRealDefFunMap

Public Member Functions
	~LLVMModuleSet ()
u32_t	getModuleNum () const
const std::vector< std::reference_wrapper< Module > > &	getLLVMModules () const
Module *	getModule (u32_t idx) const
Module &	getModuleRef (u32_t idx) const
void	dumpModulesToFile (const std::string &suffix)
const BasicBlock *	getFunExitBB (const Function *fun) const
const Function *	getRealDefFun (const Function *fun) const
const FunctionSet &	getFunctionSet () const
u32_t	getValueNodeNum () const
u32_t	getObjNodeNum () const
ValueToIDMapTy &	valSyms ()
ValueToIDMapTy &	objSyms ()
NodeID	getValueNode (const Value *V)
bool	hasValueNode (const Value *V)
NodeID	getObjectNode (const Value *V)
void	dumpSymTable ()
void	addBasicBlock (FunObjVar *fun, const BasicBlock *bb)
void	addInstructionMap (const Instruction *inst, CallICFGNode *svfInst)
void	addInstructionMap (const Instruction *inst, RetICFGNode *svfInst)
void	addInstructionMap (const Instruction *inst, IntraICFGNode *svfInst)
bool	hasLLVMValue (const SVFValue *value) const
const Value *	getLLVMValue (const SVFValue *value) const
const FunObjVar *	getFunObjVar (const Function *fun) const
FunToIDMapTy &	retSyms ()
FunToIDMapTy &	varargSyms ()
NodeID	getReturnNode (const Function *func) const
NodeID	getVarargNode (const Function *func) const
SVFBasicBlock *	getSVFBasicBlock (const BasicBlock *bb)
const Function *	getFunction (const std::string &name)
	Get the corresponding Function based on its name.
const FunObjVar *	getFunObjVar (const std::string &name)
	Get the corresponding Function based on its name.
ICFGNode *	getICFGNode (const Instruction *inst)
	Get a basic block ICFGNode.
bool	hasICFGNode (const Instruction *inst)
CallICFGNode *	getCallICFGNode (const Instruction *cs)
	get a call node
RetICFGNode *	getRetICFGNode (const Instruction *cs)
	get a return node
IntraICFGNode *	getIntraICFGNode (const Instruction *inst)
	get a intra node
FunEntryICFGNode *	getFunEntryICFGNode (const Function *fun)
	Add a function entry node.
FunExitICFGNode *	getFunExitICFGNode (const Function *fun)
	Add a function exit node.
bool	hasGlobalRep (const GlobalVariable *val) const
	Global to rep.
GlobalVariable *	getGlobalRep (const GlobalVariable *val) const
Module *	getMainLLVMModule () const
TargetABI	getTargetABI () const
LLVMContext &	getContext () const
bool	empty () const
SVFType *	getSVFType (const Type *T)
	Get or create SVFType and typeinfo.
const Type *	getLLVMType (const SVFType *T) const
	Get LLVM Type.
ObjTypeInference *	getTypeInference ()
DominatorTree &	getDomTree (const Function *fun)
std::string	getExtFuncAnnotation (const Function *fun, const std::string &funcAnnotation)
const std::vector< std::string > &	getExtFuncAnnotations (const Function *fun)
bool	hasExtFuncAnnotation (const Function *fun, const std::string &funcAnnotation)
bool	has_static (const Function *F)
bool	is_memcpy (const Function *F)
bool	is_memset (const Function *F)
bool	is_alloc (const Function *F)
bool	is_arg_alloc (const Function *F)
bool	is_alloc_stack_ret (const Function *F)
s32_t	get_alloc_arg_pos (const Function *F)
bool	is_realloc (const Function *F)
bool	is_ext (const Function *F)
void	setExtFuncAnnotations (const Function *fun, const std::vector< std::string > &funcAnnotations)

Static Public Member Functions
static LLVMModuleSet *	getLLVMModuleSet ()
static void	releaseLLVMModuleSet ()
static void	buildSVFModule (Module &mod)
static void	buildSVFModule (const std::vector< std::string > &moduleNameVec)
static void	preProcessBCs (std::vector< std::string > &moduleNameVec)

Private Member Functions
	LLVMModuleSet ()
	Constructor.
void	build ()
void	addFunctionSet (const Function *svfFunc)
void	setFunExitBB (const Function *fun, const BasicBlock *bb)
void	setFunRealDefFun (const Function *fun, const Function *realDefFun)
SVFType *	addSVFTypeInfo (const Type *t)
	Create SVFTypes.
StInfo *	collectTypeInfo (const Type *ty)
	Collect a type info.
StInfo *	collectStructInfo (const StructType *structTy, u32_t &numFields)
	Collect the struct info and set the number of fields after flattening.
StInfo *	collectArrayInfo (const ArrayType *T)
	Collect the array info.
StInfo *	collectSimpleTypeInfo (const Type *T)
	Collect simple type (non-aggregate) info.
std::vector< const Function * >	getLLVMGlobalFunctions (const GlobalVariable *global)
void	loadModules (const std::vector< std::string > &moduleNameVec)
void	loadExtAPIModules ()
void	addSVFMain ()
void	createSVFDataStructure ()
void	addToSVFVar2LLVMValueMap (const Value *val, SVFValue *svfBaseNode)
void	buildFunToFunMap ()
void	buildGlobalDefToRepMap ()
void	prePassSchedule ()
	Invoke llvm passes to modify module.
void	buildSymbolTable () const
void	collectExtFunAnnotations (const Module *mod)
CallICFGNode *	getCallBlock (const Instruction *cs)
	Get/Add a call node.
RetICFGNode *	getRetBlock (const Instruction *cs)
	Get/Add a return node.
IntraICFGNode *	getIntraBlock (const Instruction *inst)
FunEntryICFGNode *	getFunEntryBlock (const Function *fun)
	Get/Add a function entry node.
FunExitICFGNode *	getFunExitBlock (const Function *fun)
	Get/Add a function exit node.

Private Attributes
SVFIR *	svfir
std::unique_ptr< LLVMContext >	owned_ctx
std::vector< std::unique_ptr< Module > >	owned_modules
std::vector< std::reference_wrapper< Module > >	modules
TargetABI	targetABI = TargetABI::Itanium
	C++ ABI of the module being analyzed.
FunctionSetType	ExtFuncsVec
	Record some "sse_" function declarations used in other ext function definition, e.g., svf_ext_foo(), and svf_ext_foo() used in app functions.
Fun2AnnoMap	ExtFun2Annotations
	Record annotations of function in extapi.bc.
Map< const Function *, std::vector< std::string > >	func2Annotations
GlobalDefToRepMapTy	GlobalDefToRepMap
	Global definition to a rep definition map.
LLVMFun2FunObjVarMap	LLVMFun2FunObjVar
	Map an LLVM Function to an SVF Funobjvar.
LLVMBB2SVFBBMap	LLVMBB2SVFBB
LLVMType2SVFTypeMap	LLVMType2SVFType
Type2TypeInfoMap	Type2TypeInfo
ObjTypeInference *	typeInference
SVFBaseNode2LLVMValueMap	SVFBaseNode2LLVMValue
CSToCallNodeMapTy	CSToCallNodeMap
	map a callsite to its CallICFGNode
CSToRetNodeMapTy	CSToRetNodeMap
	map a callsite to its RetICFGNode
InstToBlockNodeMapTy	InstToBlockNodeMap
	map a basic block to its ICFGNode
FunToFunEntryNodeMapTy	FunToFunEntryNodeMap
	map a function to its FunExitICFGNode
FunToFunExitNodeMapTy	FunToFunExitNodeMap
	map a function to its FunEntryICFGNode
Map< const Function *, DominatorTree >	FunToDominatorTree
ValueToIDMapTy	valSymMap
	map a value to its sym id
ValueToIDMapTy	objSymMap
	map a obj reference to its sym id
FunToIDMapTy	returnSymMap
	return map
FunToIDMapTy	varargSymMap
	vararg map
FunctionSet	funSet
FunToExitBBMap	funToExitBB
FunToRealDefFunMap	funToRealDefFun

Static Private Attributes
static LLVMModuleSet *	llvmModuleSet = nullptr
static bool	preProcessed = false

Friends
class	SVFIRBuilder
class	ICFGBuilder
class	SymbolTableBuilder

Detailed Description

Definition at line 47 of file LLVMModule.h.

Member Typedef Documentation

CSToCallNodeMapTy

typedef Map<const Instruction*, CallICFGNode *> SVF::LLVMModuleSet::CSToCallNodeMapTy

Definition at line 67 of file LLVMModule.h.

CSToRetNodeMapTy

typedef Map<const Instruction*, RetICFGNode *> SVF::LLVMModuleSet::CSToRetNodeMapTy

Definition at line 68 of file LLVMModule.h.

Fun2AnnoMap

typedef Map<std::string, std::vector<std::string> > SVF::LLVMModuleSet::Fun2AnnoMap

Definition at line 65 of file LLVMModule.h.

FunctionSet

typedef std::vector<const Function*> SVF::LLVMModuleSet::FunctionSet

Definition at line 79 of file LLVMModule.h.

FunctionSetType

typedef std::vector<const Function*> SVF::LLVMModuleSet::FunctionSetType

Definition at line 55 of file LLVMModule.h.

FunDeclToDefMapTy

typedef Map<const Function*, const Function*> SVF::LLVMModuleSet::FunDeclToDefMapTy

Definition at line 56 of file LLVMModule.h.

FunDefToDeclsMapTy

typedef Map<const Function*, FunctionSetType> SVF::LLVMModuleSet::FunDefToDeclsMapTy

Definition at line 57 of file LLVMModule.h.

FunToExitBBMap

typedef Map<const Function*, const BasicBlock*> SVF::LLVMModuleSet::FunToExitBBMap

Definition at line 80 of file LLVMModule.h.

FunToFunEntryNodeMapTy

typedef Map<const Function*, FunEntryICFGNode *> SVF::LLVMModuleSet::FunToFunEntryNodeMapTy

Definition at line 70 of file LLVMModule.h.

FunToFunExitNodeMapTy

typedef Map<const Function*, FunExitICFGNode *> SVF::LLVMModuleSet::FunToFunExitNodeMapTy

Definition at line 71 of file LLVMModule.h.

FunToIDMapTy

typedef OrderedMap<const Function*, NodeID> SVF::LLVMModuleSet::FunToIDMapTy

Definition at line 77 of file LLVMModule.h.

FunToRealDefFunMap

typedef Map<const Function*, const Function *> SVF::LLVMModuleSet::FunToRealDefFunMap

Definition at line 81 of file LLVMModule.h.

GlobalDefToRepMapTy

typedef Map<const GlobalVariable*, GlobalVariable*> SVF::LLVMModuleSet::GlobalDefToRepMapTy

Definition at line 58 of file LLVMModule.h.

InstToBlockNodeMapTy

typedef Map<const Instruction*, IntraICFGNode *> SVF::LLVMModuleSet::InstToBlockNodeMapTy

Definition at line 69 of file LLVMModule.h.

LLVMBB2SVFBBMap

typedef Map<const BasicBlock*, SVFBasicBlock*> SVF::LLVMModuleSet::LLVMBB2SVFBBMap

Definition at line 61 of file LLVMModule.h.

LLVMFun2FunObjVarMap

typedef Map<const Function*, FunObjVar*> SVF::LLVMModuleSet::LLVMFun2FunObjVarMap

Definition at line 60 of file LLVMModule.h.

LLVMType2SVFTypeMap

typedef Map<const Type*, SVFType*> SVF::LLVMModuleSet::LLVMType2SVFTypeMap

Definition at line 63 of file LLVMModule.h.

SVFBaseNode2LLVMValueMap

typedef Map<const SVFValue*, const Value*> SVF::LLVMModuleSet::SVFBaseNode2LLVMValueMap

Definition at line 62 of file LLVMModule.h.

Type2TypeInfoMap

typedef Map<const Type*, StInfo*> SVF::LLVMModuleSet::Type2TypeInfoMap

Definition at line 64 of file LLVMModule.h.

ValueToIDMapTy

typedef OrderedMap<const Value*, NodeID> SVF::LLVMModuleSet::ValueToIDMapTy

llvm value to sym id map local (%) and global (@) identifiers are pointer types which have a value node id.

Definition at line 75 of file LLVMModule.h.

Constructor & Destructor Documentation

LLVMModuleSet()

LLVMModuleSet::LLVMModuleSet ( )

private

Constructor.

Definition at line 83 of file LLVMModule.cpp.

    : svfir(PAG::getPAG()), typeInference(new ObjTypeInference())
{
}

~LLVMModuleSet()

LLVMModuleSet::~LLVMModuleSet

(

)

Definition at line 88 of file LLVMModule.cpp.

{
 
    delete typeInference;
    typeInference = nullptr;
 
}

Member Function Documentation

addBasicBlock()

void SVF::LLVMModuleSet::addBasicBlock ( FunObjVar * fun, const BasicBlock * bb )

inline

Definition at line 239 of file LLVMModule.h.

    {
        SVFBasicBlock* svfBB = fun->getBasicBlockGraph()->addBasicBlock(bb->getName().str());
        LLVMBB2SVFBB[bb] = svfBB;
        SVFBaseNode2LLVMValue[svfBB] = bb;
    }

addFunctionSet()

void SVF::LLVMModuleSet::addFunctionSet ( const Function * svfFunc )

inlineprivate

Definition at line 452 of file LLVMModule.h.

    {
        funSet.push_back(svfFunc);
    }

addInstructionMap() [1/3]

void SVF::LLVMModuleSet::addInstructionMap ( const Instruction * inst, CallICFGNode * svfInst )

inline

Definition at line 246 of file LLVMModule.h.

    {
        CSToCallNodeMap[inst] = svfInst;
        addToSVFVar2LLVMValueMap(inst, svfInst);
    }

addInstructionMap() [2/3]

void SVF::LLVMModuleSet::addInstructionMap ( const Instruction * inst, IntraICFGNode * svfInst )

inline

Definition at line 256 of file LLVMModule.h.

    {
        InstToBlockNodeMap[inst] = svfInst;
        addToSVFVar2LLVMValueMap(inst, svfInst);
    }

addInstructionMap() [3/3]

void SVF::LLVMModuleSet::addInstructionMap ( const Instruction * inst, RetICFGNode * svfInst )

inline

Definition at line 251 of file LLVMModule.h.

    {
        CSToRetNodeMap[inst] = svfInst;
        addToSVFVar2LLVMValueMap(inst, svfInst);
    }

addSVFMain()

void LLVMModuleSet::addSVFMain ( )

private

Definition at line 509 of file LLVMModule.cpp.

{
    std::vector<const Function*> ctor_funcs;
    std::vector<const Function*> dtor_funcs;
    Function* orgMain = 0;
    Module* mainMod = nullptr;
 
    for (Module &mod : modules)
    {
        // Collect ctor and dtor functions
        for (const GlobalVariable& global : mod.globals())
        {
            if (global.getName() == SVF_GLOBAL_CTORS && global.hasInitializer())
            {
                ctor_funcs = getLLVMGlobalFunctions(&global);
            }
            else if (global.getName() == SVF_GLOBAL_DTORS && global.hasInitializer())
            {
                dtor_funcs = getLLVMGlobalFunctions(&global);
            }
        }
 
        // Find main function
        for (auto &func : mod)
        {
            auto funName = func.getName();
 
            assert(!(funName == SVF_MAIN_FUNC_NAME) && SVF_MAIN_FUNC_NAME " already defined");
 
            if (funName == "main")
            {
                orgMain = &func;
                mainMod = &mod;
            }
        }
    }
 
    // Only create svf.main when the original main function is found, and also
    // there are global constructor or destructor functions.
    if (orgMain && getModuleNum() > 0 &&
            (ctor_funcs.size() > 0 || dtor_funcs.size() > 0))
    {
        assert(mainMod && "Module with main function not found.");
        Module& M = *mainMod;
        // char **
        Type* ptr = PointerType::getUnqual(M.getContext());
        Type* i32 = IntegerType::getInt32Ty(M.getContext());
        // define void @svf.main(i32, i8**, i8**)
        FunctionCallee svfmainFn = M.getOrInsertFunction(
                                       SVF_MAIN_FUNC_NAME,
                                       Type::getVoidTy(M.getContext()),
                                       i32,ptr,ptr
                                   );
        Function* svfmain = SVFUtil::dyn_cast<Function>(svfmainFn.getCallee());
        svfmain->setCallingConv(llvm::CallingConv::C);
        BasicBlock* block = BasicBlock::Create(M.getContext(), "entry", svfmain);
        IRBuilder Builder(block);
        // emit "call void @ctor()". ctor_funcs is sorted so the functions are
        // emitted in the order of priority
        for (auto& ctor : ctor_funcs)
        {
            auto target = M.getOrInsertFunction(
                              ctor->getName(),
                              Type::getVoidTy(M.getContext())
                          );
            Builder.CreateCall(target);
        }
        // main() should be called after all ctor functions and before dtor
        // functions.
        Function::arg_iterator arg_it = svfmain->arg_begin();
        Value* args[] = {arg_it, arg_it + 1, arg_it + 2};
        size_t cnt = orgMain->arg_size();
        assert(cnt <= 3 && "Too many arguments for main()");
        Builder.CreateCall(orgMain, llvm::ArrayRef<Value*>(args, args + cnt));
        // emit "call void @dtor()". dtor_funcs is sorted so the functions are
        // emitted in the order of priority
        for (auto& dtor : dtor_funcs)
        {
            auto target = M.getOrInsertFunction(dtor->getName(), Type::getVoidTy(M.getContext()));
            Builder.CreateCall(target);
        }
        // return;
        Builder.CreateRetVoid();
    }
    else
    {
        // use SVF::Options to record whether svf.main is added or not
        Options::SVFMain.setValue(false);
    }
}

addSVFTypeInfo()

SVFType * LLVMModuleSet::addSVFTypeInfo ( const Type * t )

private

Create SVFTypes.

Definition at line 1288 of file LLVMModule.cpp.

{
    assert(LLVMType2SVFType.find(T) == LLVMType2SVFType.end() &&
           "SVFType has been added before");
 
    // add SVFType's LLVM byte size iff T isSized(), otherwise byteSize is 1 (default value)
    u32_t byteSize = 1;
    if (T->isSized())
    {
        const llvm::DataLayout &DL = LLVMModuleSet::getLLVMModuleSet()->
                                     getMainLLVMModule()->getDataLayout();
        Type *mut_T = const_cast<Type *>(T);
        byteSize = DL.getTypeAllocSize(mut_T);
    }
 
    SVFType* svftype;
 
    u32_t id = NodeIDAllocator::get()->allocateTypeId();
    if (SVFUtil::isa<PointerType>(T))
    {
        svftype = new SVFPointerType(id, byteSize);
    }
    else if (const IntegerType* intT = SVFUtil::dyn_cast<IntegerType>(T))
    {
        auto svfIntT = new SVFIntegerType(id, byteSize);
        unsigned signWidth = intT->getBitWidth();
        assert(signWidth < INT16_MAX && "Integer width too big");
        svfIntT->setSignAndWidth(intT->getSignBit() ? -signWidth : signWidth);
        svftype = svfIntT;
    }
    else if (const FunctionType* ft = SVFUtil::dyn_cast<FunctionType>(T))
    {
        std::vector<const SVFType*> paramTypes;
        for (const auto& t: ft->params())
        {
            paramTypes.push_back(getSVFType(t));
        }
        svftype = new SVFFunctionType(id, getSVFType(ft->getReturnType()), paramTypes, ft->isVarArg());
    }
    else if (const StructType* st = SVFUtil::dyn_cast<StructType>(T))
    {
        std::vector<const SVFType*> fieldTypes;
 
        for (const auto& t: st->elements())
        {
            fieldTypes.push_back(getSVFType(t));
        }
        auto svfst = new SVFStructType(id, fieldTypes, byteSize);
        if (st->hasName())
            svfst->setName(st->getName().str());
        svftype = svfst;
    }
    else if (const auto at = SVFUtil::dyn_cast<ArrayType>(T))
    {
        auto svfat = new SVFArrayType(id, byteSize);
        svfat->setNumOfElement(at->getNumElements());
        svfat->setTypeOfElement(getSVFType(at->getElementType()));
        svftype = svfat;
    }
    else
    {
        std::string buffer;
        auto ot = new SVFOtherType(id, T->isSingleValueType(), byteSize);
        llvm::raw_string_ostream(buffer) << *T;
        ot->setRepr(std::move(buffer));
        svftype = ot;
    }
 
    svfir->addTypeInfo(svftype);
    LLVMType2SVFType[T] = svftype;
 
    return svftype;
}

addToSVFVar2LLVMValueMap()

void LLVMModuleSet::addToSVFVar2LLVMValueMap ( const Value * val, SVFValue * svfBaseNode )

private

Definition at line 1150 of file LLVMModule.cpp.

{
    SVFBaseNode2LLVMValue[svfBaseNode] = val;
    svfBaseNode->setSourceLoc(LLVMUtil::getSourceLoc(val));
    svfBaseNode->setName(val->getName().str());
}

build()

void LLVMModuleSet::build ( )

private

Definition at line 163 of file LLVMModule.cpp.

{
    if (!empty())
    {
        targetABI = LLVMUtil::detectTargetABI(
                        LLVMUtil::getTargetTriple(getMainLLVMModule()));
    }
 
    if(preProcessed==false)
        prePassSchedule();
 
    buildFunToFunMap();
    buildGlobalDefToRepMap();
 
    if (Options::SVFMain())
        addSVFMain();
 
    createSVFDataStructure();
 
}

buildFunToFunMap()

void LLVMModuleSet::buildFunToFunMap ( )

private

Keep svf_main() function and all the functions called in svf_main()

app functions

App Func decl -> SVF extern Func def

Overwrite App Func def -> SVF extern Func def

Definition at line 668 of file LLVMModule.cpp.

{
    Set<const Function*> appFunDecls, appFunDefs, extFuncs, clonedFuncs;
    OrderedSet<string> appFuncDeclNames, appFuncDefNames, extFunDefNames, intersectNames;
    Map<const Function*, const Function*> extFuncs2ClonedFuncs;
    Module* appModule = nullptr;
    Module* extModule = nullptr;
 
    for (Module& mod : modules)
    {
        // extapi.bc functions
        if (mod.getName().str() == ExtAPI::getExtAPI()->getExtBcPath())
        {
            collectExtFunAnnotations(&mod);
            extModule = &mod;
            for (const Function& fun : mod.functions())
            {
                // there is main declaration in ext bc, it should be mapped to
                // main definition in app bc.
                if (fun.getName().str() == "main")
                {
                    appFunDecls.insert(&fun);
                    appFuncDeclNames.insert(fun.getName().str());
                }
                else if (fun.getName().str() == "svf__main")
                {
                    ExtFuncsVec.push_back(&fun);
                }
                else
                {
                    extFuncs.insert(&fun);
                    extFunDefNames.insert(fun.getName().str());
                }
            }
        }
        else
        {
            appModule = &mod;
            for (const Function& fun : mod.functions())
            {
                if (fun.isDeclaration())
                {
                    appFunDecls.insert(&fun);
                    appFuncDeclNames.insert(fun.getName().str());
                }
                else
                {
                    appFunDefs.insert(&fun);
                    appFuncDefNames.insert(fun.getName().str());
                }
            }
        }
    }
 
    // Find the intersectNames between appFuncDefNames and externalFunDefNames
    std::set_intersection(
        appFuncDefNames.begin(), appFuncDefNames.end(), extFunDefNames.begin(), extFunDefNames.end(),
        std::inserter(intersectNames, intersectNames.end()));
 
    auto cloneAndReplaceFunction = [&](const Function* extFunToClone, Function* appFunToReplace, Module* appModule, bool cloneBody) -> Function*
    {
        assert(!(appFunToReplace == NULL && appModule == NULL) && "appFunToReplace and appModule cannot both be NULL");
 
        if (appFunToReplace)
        {
            appModule = appFunToReplace->getParent();
        }
        Function* clonedFunction = Function::Create(extFunToClone->getFunctionType(),
            Function::ExternalLinkage,
            extFunToClone->getName());
        // Map the arguments of the new function to the arguments of extFunToClone
        llvm::ValueToValueMapTy valueMap;
        Function::arg_iterator destArg = clonedFunction->arg_begin();
        for (Function::const_arg_iterator srcArg = extFunToClone->arg_begin(); srcArg != extFunToClone->arg_end(); ++srcArg)
        {
            destArg->setName(srcArg->getName()); // Copy the name of the original argument
            valueMap[&*srcArg] = &*destArg++; // Add a mapping from the old arg to the new arg
        }
        if (cloneBody)
        {
            // Collect global variables referenced by extFunToClone
            // This step identifies all global variables used within the function to be cloned
            std::set<GlobalVariable*> referencedGlobals;
            for (const BasicBlock& BB : *extFunToClone)
            {
                for (const Instruction& I : BB)
                {
                    for (const Value* operand : I.operands())
                    {
                        // Check if the operand is a global variable
                        if (const GlobalVariable* GV = SVFUtil::dyn_cast<GlobalVariable>(operand))
                        {
                            referencedGlobals.insert(const_cast<GlobalVariable*>(GV));
                        }
                    }
                }
            }
 
            // Copy global variables to target module and update valueMap
            // When cloning a function, we need to ensure all global variables it references are available in the target module
            for (GlobalVariable* GV : referencedGlobals)
            {
                // Check if the global variable already exists in the target module
                GlobalVariable* existingGV = appModule->getGlobalVariable(GV->getName());
                if (existingGV)
                {
                    // If the global variable already exists, ensure type consistency
                    assert(existingGV->getType() == GV->getType() && "Global variable type mismatch in client module!");
                    // Map the original global to the existing one in the target module
                    valueMap[GV] = existingGV; // Map to existing global variable
                }
                else
                {
                    // If the global variable doesn't exist in the target module, create a new one with the same properties
                    GlobalVariable* newGV = new GlobalVariable(
                        *appModule,                   // Target module
                        GV->getValueType(),           // Type of the global variable
                        GV->isConstant(),             // Whether it's constant
                        GV->getLinkage(),             // Linkage type
                        nullptr,                      // No initializer yet
                        GV->getName(),                // Same name
                        nullptr,                      // No insert before instruction
                        GV->getThreadLocalMode(),     // Thread local mode
                        GV->getAddressSpace()         // Address space
                    );
 
                    // Copy initializer if present to maintain the global's value
                    if (GV->hasInitializer())
                    {
                        Constant* init = GV->getInitializer();
                        newGV->setInitializer(init); // Simple case: direct copy
                    }
 
                    // Copy other attributes like alignment to ensure identical behavior
                    newGV->copyAttributesFrom(GV);
 
                    // Add mapping from original global to the new one for use during function cloning
                    valueMap[GV] = newGV;
                }
            }
 
            // Clone function body with updated valueMap
            llvm::SmallVector<ReturnInst*, 8> ignoredReturns;
            CloneFunctionInto(clonedFunction, extFunToClone, valueMap, llvm::CloneFunctionChangeType::LocalChangesOnly, ignoredReturns, "", nullptr);
        }
        if (appFunToReplace)
        {
            // Replace all uses of appFunToReplace with clonedFunction
            appFunToReplace->replaceAllUsesWith(clonedFunction);
            std::string oldFunctionName = appFunToReplace->getName().str();
            // Delete the old function
            appFunToReplace->eraseFromParent();
            appModule->getFunctionList().push_back(clonedFunction);
            clonedFunction->setName(oldFunctionName);
        }
        else
        {
            appModule->getFunctionList().push_back(clonedFunction);
        }
        return clonedFunction;
    };

    for (const Function* appFunDecl : appFunDecls)
    {
        std::string appFunDeclName = LLVMUtil::restoreFuncName(appFunDecl->getName().str());
        for (const Function* extFun : extFuncs)
        {
            if (extFun->getName().str().compare(appFunDeclName) == 0)
            {
                auto it = ExtFun2Annotations.find(extFun->getName().str());
                // Without annotations, this function is normal function with useful function body
                if (it == ExtFun2Annotations.end())
                {
                    Function* clonedFunction = cloneAndReplaceFunction(const_cast<Function*>(extFun), const_cast<Function*>(appFunDecl), nullptr, true);
                    extFuncs2ClonedFuncs[extFun] = clonedFunction;
                    clonedFuncs.insert(clonedFunction);
                }
                else
                {
                    ExtFuncsVec.push_back(appFunDecl);
                }
                break;
            }
        }
    }

    for (string sameFuncDef: intersectNames)
    {
        Function* appFuncDef = appModule->getFunction(sameFuncDef);
        Function* extFuncDef = extModule->getFunction(sameFuncDef);
        if (appFuncDef == nullptr || extFuncDef == nullptr)
            continue;
 
        FunctionType *appFuncDefType = appFuncDef->getFunctionType();
        FunctionType *extFuncDefType = extFuncDef->getFunctionType();
        if (appFuncDefType != extFuncDefType)
            continue;
 
        auto it = ExtFun2Annotations.find(sameFuncDef);
        if (it != ExtFun2Annotations.end())
        {
            std::vector<std::string> annotations = it->second;
            if (annotations.size() == 1 && annotations[0].find("OVERWRITE") != std::string::npos)
            {
                Function* clonedFunction = cloneAndReplaceFunction(const_cast<Function*>(extFuncDef), const_cast<Function*>(appFuncDef), nullptr, true);
                extFuncs2ClonedFuncs[extFuncDef] = clonedFunction;
                clonedFuncs.insert(clonedFunction);
            }
            else
            {
                if (annotations.size() >= 2)
                {
                    for (const auto& annotation : annotations)
                    {
                        if(annotation.find("OVERWRITE") != std::string::npos)
                        {
                            assert(false && "overwrite and other annotations cannot co-exist");
                        }
                    }
                }
            }
        }
    }
 
    auto linkFunctions = [&](Function* caller, Function* callee)
    {
        for (inst_iterator I = inst_begin(caller), E = inst_end(caller); I != E; ++I)
        {
            Instruction *inst = &*I;
 
            if (CallInst *callInst = SVFUtil::dyn_cast<CallInst>(inst))
            {
                Function *calledFunc = callInst->getCalledFunction();
 
                if (calledFunc && calledFunc->getName() == callee->getName())
                {
                    callInst->setCalledFunction(callee);
                }
            }
        }
    };
 
    std::function<void(const Function*, Function*)> cloneAndLinkFunction;
    cloneAndLinkFunction = [&](const Function* extFunToClone, Function* appClonedFun)
    {
        if (clonedFuncs.find(extFunToClone) != clonedFuncs.end())
            return;
 
        Module* appModule = appClonedFun->getParent();
        // Check if the function already exists in the parent module
        if (appModule->getFunction(extFunToClone->getName()))
        {
            // The function already exists, no need to clone, but need to link it with the caller
            Function*  func = appModule->getFunction(extFunToClone->getName());
            linkFunctions(appClonedFun, func);
            return;
        }
        // Decide whether to clone the function body based on ExtFun2Annotations
        bool cloneBody = true;
        auto it = ExtFun2Annotations.find(extFunToClone->getName().str());
        if (it != ExtFun2Annotations.end())
        {
            std::vector<std::string> annotations = it->second;
            if (!(annotations.size() == 1 && annotations[0].find("OVERWRITE") != std::string::npos))
            {
                cloneBody = false;
            }
        }
 
        Function* clonedFunction = cloneAndReplaceFunction(extFunToClone, nullptr, appModule, cloneBody);
 
        clonedFuncs.insert(clonedFunction);
        // Add the cloned function to ExtFuncsVec for further processing
        ExtFuncsVec.push_back(clonedFunction);
 
        linkFunctions(appClonedFun, clonedFunction);
 
        std::vector<const Function*> calledFunctions = LLVMUtil::getCalledFunctions(extFunToClone);
 
        for (const auto& calledFunction : calledFunctions)
        {
            cloneAndLinkFunction(calledFunction, clonedFunction);
        }
    };
 
    // Recursive clone called functions
    for (const auto& pair : extFuncs2ClonedFuncs)
    {
        Function* extFun = const_cast<Function*>(pair.first);
        Function* clonedExtFun = const_cast<Function*>(pair.second);
        std::vector<const Function*> extCalledFuns = LLVMUtil::getCalledFunctions(extFun);
 
        for (const auto& extCalledFun : extCalledFuns)
        {
            cloneAndLinkFunction(extCalledFun, clonedExtFun);
        }
    }
 
    // Remove unused annotations in ExtFun2Annotations according to the functions in ExtFuncsVec
    Fun2AnnoMap newFun2AnnoMap;
    for (const Function* extFun : ExtFuncsVec)
    {
        std::string name = LLVMUtil::restoreFuncName(extFun->getName().str());
        auto it = ExtFun2Annotations.find(name);
        if (it != ExtFun2Annotations.end())
        {
            std::string newKey = name;
            if (name != extFun->getName().str())
            {
                newKey = extFun->getName().str();
            }
            newFun2AnnoMap.insert({newKey, it->second});
        }
    }
    ExtFun2Annotations.swap(newFun2AnnoMap);
 
    // Remove ExtAPI module from modules
    auto it = std::find_if(modules.begin(), modules.end(),
                           [&extModule](const std::reference_wrapper<llvm::Module>& moduleRef)
    {
        return &moduleRef.get() == extModule;
    });
 
    if (it != modules.end())
    {
        size_t index = std::distance(modules.begin(), it);
        modules.erase(it);
        owned_modules.erase(owned_modules.begin() + index);
    }
}

buildGlobalDefToRepMap()

void LLVMModuleSet::buildGlobalDefToRepMap ( )

private

Definition at line 1004 of file LLVMModule.cpp.

{
    typedef Map<string, Set<GlobalVariable*>> NameToGlobalsMapTy;
    NameToGlobalsMapTy nameToGlobalsMap;
    for (Module &mod : modules)
    {
        // Collect ctor and dtor functions
        for (GlobalVariable& global : mod.globals())
        {
            if (global.hasPrivateLinkage())
                continue;
            string name = global.getName().str();
            if (name.empty())
                continue;
            nameToGlobalsMap[std::move(name)].insert(&global);
        }
    }
 
    for (const auto& pair : nameToGlobalsMap)
    {
        const Set<GlobalVariable*> &globals = pair.second;
 
        const auto repIt =
            std::find_if(globals.begin(), globals.end(),
                         [](GlobalVariable* g)
        {
            return g->hasInitializer();
        });
        GlobalVariable* rep =
            repIt != globals.end()
            ? *repIt
            // When there is no initializer, just pick the first one.
            : (assert(!globals.empty() && "Empty global set"),
               *globals.begin());
 
        for (const GlobalVariable* cur : globals)
        {
            GlobalDefToRepMap[cur] = rep;
        }
    }
}

buildSVFModule() [1/2]

void LLVMModuleSet::buildSVFModule ( const std::vector< std::string > & moduleNameVec )

static

Definition at line 125 of file LLVMModule.cpp.

{
    double startSVFModuleTime = SVFStat::getClk(true);
 
    LLVMModuleSet* mset = getLLVMModuleSet();
 
    mset->loadModules(moduleNameVec);   // Populates `modules`; can get context via `this->getContext()`
    mset->loadExtAPIModules();          // Uses context from first module through `this->getContext()`
 
    if (!moduleNameVec.empty())
    {
        PAG::getPAG()->setModuleIdentifier(moduleNameVec.front());
    }
 
    mset->build();
 
    double endSVFModuleTime = SVFStat::getClk(true);
    SVFStat::timeOfBuildingLLVMModule =
        (endSVFModuleTime - startSVFModuleTime) / TIMEINTERVAL;
 
    mset->buildSymbolTable();
}

buildSVFModule() [2/2]

void LLVMModuleSet::buildSVFModule ( Module & mod )

static

Definition at line 110 of file LLVMModule.cpp.

{
    LLVMModuleSet* mset = getLLVMModuleSet();
 
    double startSVFModuleTime = SVFStat::getClk(true);
    PAG::getPAG()->setModuleIdentifier(mod.getModuleIdentifier());
    mset->modules.emplace_back(mod);    // Populates `modules`; can get context via `this->getContext()`
    mset->loadExtAPIModules();          // Uses context from module through `this->getContext()`
    mset->build();
    double endSVFModuleTime = SVFStat::getClk(true);
    SVFStat::timeOfBuildingLLVMModule = (endSVFModuleTime - startSVFModuleTime)/TIMEINTERVAL;
 
    mset->buildSymbolTable();
}

buildSymbolTable()

void LLVMModuleSet::buildSymbolTable ( ) const

private

building symbol table

Definition at line 148 of file LLVMModule.cpp.

{
    double startSymInfoTime = SVFStat::getClk(true);
    if (!SVFIR::pagReadFromTXT())
    {
        DBOUT(DGENERAL, SVFUtil::outs() << SVFUtil::pasMsg("Building Symbol table ...\n"));
        SymbolTableBuilder builder(svfir);
        builder.buildMemModel();
    }
    double endSymInfoTime = SVFStat::getClk(true);
    SVFStat::timeOfBuildingSymbolTable =
        (endSymInfoTime - startSymInfoTime) / TIMEINTERVAL;
}

collectArrayInfo()

StInfo * LLVMModuleSet::collectArrayInfo ( const ArrayType * ty )

private

Collect the array info.

Fill in StInfo for an array type.

array without any element (this is not true in C/C++ arrays) we assume there is an empty dummy element

Array's flatten field infor is the same as its element's flatten infor.

Flatten arrays, map each array element index i to flattened index (i * nfE * totalElemNum)/outArrayElemNum nfE>1 if the array element is a struct with more than one field.

Definition at line 1365 of file LLVMModule.cpp.

{
    u64_t totalElemNum = ty->getNumElements();
    const Type* elemTy = ty->getElementType();
    while (const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(elemTy))
    {
        totalElemNum *= aty->getNumElements();
        elemTy = aty->getElementType();
    }
 
    StInfo* stInfo = new StInfo(totalElemNum);
    const SVFType* elemSvfType = getSVFType(elemTy);

    if (totalElemNum == 0)
    {
        stInfo->addFldWithType(0, elemSvfType, 0);
        stInfo->setNumOfFieldsAndElems(1, 1);
        stInfo->getFlattenFieldTypes().push_back(elemSvfType);
        stInfo->getFlattenElementTypes().push_back(elemSvfType);
        return stInfo;
    }

    StInfo* elemStInfo = collectTypeInfo(elemTy);
    u32_t nfF = elemStInfo->getNumOfFlattenFields();
    u32_t nfE = elemStInfo->getNumOfFlattenElements();
    for (u32_t j = 0; j < nfF; j++)
    {
        const SVFType* fieldTy = elemStInfo->getFlattenFieldTypes()[j];
        stInfo->getFlattenFieldTypes().push_back(fieldTy);
    }

    u32_t outArrayElemNum = ty->getNumElements();
    for (u32_t i = 0; i < outArrayElemNum; ++i)
    {
        auto idx = (i * nfE * totalElemNum) / outArrayElemNum;
        stInfo->addFldWithType(0, elemSvfType, idx);
    }
 
    for (u32_t i = 0; i < totalElemNum; ++i)
    {
        for (u32_t j = 0; j < nfE; ++j)
        {
            const SVFType* et = elemStInfo->getFlattenElementTypes()[j];
            stInfo->getFlattenElementTypes().push_back(et);
        }
    }
 
    assert(stInfo->getFlattenElementTypes().size() == nfE * totalElemNum &&
           "typeForArray size incorrect!!!");
    stInfo->setNumOfFieldsAndElems(nfF, nfE * totalElemNum);
 
    return stInfo;
}

collectExtFunAnnotations()

void LLVMModuleSet::collectExtFunAnnotations ( const Module * mod )

private

Non-opaque pointer

Opaque pointer

Definition at line 600 of file LLVMModule.cpp.

{
    GlobalVariable *glob = mod->getGlobalVariable("llvm.global.annotations");
    if (glob == nullptr || !glob->hasInitializer())
        return;
 
    ConstantArray *ca = SVFUtil::dyn_cast<ConstantArray>(glob->getInitializer());
    if (ca == nullptr)
        return;
 
    for (unsigned i = 0; i < ca->getNumOperands(); ++i)
    {
        ConstantStruct *structAn = SVFUtil::dyn_cast<ConstantStruct>(ca->getOperand(i));
        if (structAn == nullptr || structAn->getNumOperands() == 0)
            continue;
 
        // Check if the annotation is for a function
        Function* fun = nullptr;
        GlobalVariable *annotateStr = nullptr;
        if (ConstantExpr *expr = SVFUtil::dyn_cast<ConstantExpr>(structAn->getOperand(0)))
        {
            if (expr->getOpcode() == Instruction::BitCast && SVFUtil::isa<Function>(expr->getOperand(0)))
                fun = SVFUtil::cast<Function>(expr->getOperand(0));
 
            ConstantExpr *note = SVFUtil::cast<ConstantExpr>(structAn->getOperand(1));
            if (note->getOpcode() != Instruction::GetElementPtr)
                continue;
 
            annotateStr = SVFUtil::dyn_cast<GlobalVariable>(note->getOperand(0));
        }
        else
        {
            fun = SVFUtil::dyn_cast<Function>(structAn->getOperand(0));
            annotateStr = SVFUtil::dyn_cast<GlobalVariable>(structAn->getOperand(1));
        }
 
        if (!fun || annotateStr == nullptr || !annotateStr->hasInitializer())
            continue;;
 
        ConstantDataSequential *data = SVFUtil::dyn_cast<ConstantDataSequential>(annotateStr->getInitializer());
        if (data && data->isString())
        {
            std::string annotation = data->getAsString().str();
            if (!annotation.empty())
                ExtFun2Annotations[fun->getName().str()].push_back(annotation);
        }
    }
}

collectSimpleTypeInfo()

StInfo * LLVMModuleSet::collectSimpleTypeInfo ( const Type * ty )

private

Collect simple type (non-aggregate) info.

Collect simple type (non-aggregate) info

Only one field

Definition at line 1485 of file LLVMModule.cpp.

{
    StInfo* stInfo = new StInfo(1);
    SVFType* svfType = getSVFType(ty);
    stInfo->addFldWithType(0, svfType, 0);
 
    stInfo->getFlattenFieldTypes().push_back(svfType);
    stInfo->getFlattenElementTypes().push_back(svfType);
    stInfo->setNumOfFieldsAndElems(1,1);
 
    return stInfo;
}

collectStructInfo()

StInfo * LLVMModuleSet::collectStructInfo ( const StructType * structTy, u32_t & numFields )

private

Collect the struct info and set the number of fields after flattening.

Fill in struct_info for T. Given a Struct type, we recursively extend and record its fields and types.

The struct info should not be processed before

Definition at line 1428 of file LLVMModule.cpp.

{
    StInfo* stInfo = new StInfo(1);
 
    // Number of fields after flattening the struct
    numFields = 0;
    // The offset when considering array stride info
    u32_t strideOffset = 0;
    for (const Type* elemTy : structTy->elements())
    {
        const SVFType* elemSvfTy = getSVFType(elemTy);
        // offset with int_32 (s32_t) is large enough and won't overflow
        stInfo->addFldWithType(numFields, elemSvfTy, strideOffset);
 
        if (SVFUtil::isa<StructType, ArrayType>(elemTy))
        {
            StInfo* subStInfo = collectTypeInfo(elemTy);
            u32_t nfF = subStInfo->getNumOfFlattenFields();
            u32_t nfE = subStInfo->getNumOfFlattenElements();
            // Copy ST's info, whose element 0 is the size of ST itself.
            for (u32_t j = 0; j < nfF; ++j)
            {
                const SVFType* elemTy = subStInfo->getFlattenFieldTypes()[j];
                stInfo->getFlattenFieldTypes().push_back(elemTy);
            }
            numFields += nfF;
            strideOffset += nfE;
            for (u32_t tpj = 0; tpj < nfE; ++tpj)
            {
                const SVFType* ty = subStInfo->getFlattenElementTypes()[tpj];
                stInfo->getFlattenElementTypes().push_back(ty);
            }
 
        }
        else
        {
            // Simple type
            numFields += 1;
            strideOffset += 1;
            stInfo->getFlattenFieldTypes().push_back(elemSvfTy);
            stInfo->getFlattenElementTypes().push_back(elemSvfTy);
        }
    }
 
    assert(stInfo->getFlattenElementTypes().size() == strideOffset &&
           "typeForStruct size incorrect!");
    stInfo->setNumOfFieldsAndElems(numFields,strideOffset);
 
    return stInfo;
}

collectTypeInfo()

StInfo * LLVMModuleSet::collectTypeInfo ( const Type * ty )

private

Collect a type info.

Definition at line 1256 of file LLVMModule.cpp.

{
    Type2TypeInfoMap::iterator tit = Type2TypeInfo.find(T);
    if (tit != Type2TypeInfo.end())
    {
        return tit->second;
    }
    // No such StInfo for T, create it now.
    StInfo* stInfo;
    if (const ArrayType* aty = SVFUtil::dyn_cast<ArrayType>(T))
    {
        stInfo = collectArrayInfo(aty);
    }
    else if (const StructType* sty = SVFUtil::dyn_cast<StructType>(T))
    {
        u32_t nf;
        stInfo = collectStructInfo(sty, nf);
        if (nf > svfir->maxStSize)
        {
            svfir->maxStruct = getSVFType(sty);
            svfir->maxStSize = nf;
        }
    }
    else
    {
        stInfo = collectSimpleTypeInfo(T);
    }
    Type2TypeInfo.emplace(T, stInfo);
    svfir->addStInfo(stInfo);
    return stInfo;
}

createSVFDataStructure()

void LLVMModuleSet::createSVFDataStructure ( )

private

Function

set exit block: exit basic block must have no successors and have a return instruction

Definition at line 184 of file LLVMModule.cpp.

{
    SVFType::svfI8Ty = getSVFType(getTypeInference()->int8Type());
    SVFType::svfPtrTy = getSVFType(getTypeInference()->ptrType());
    // Functions need to be retrieved in the order of insertion
    // candidateDefs is the vector for all used defined functions
    // candidateDecls is the vector for all used declared functions
    std::vector<const Function*> candidateDefs, candidateDecls;
 
    for (Module& mod : modules)
    {
        for (Function& func : mod.functions())
        {
            if (func.isDeclaration())
            {
                candidateDecls.push_back(&func);
            }
            else
            {
                candidateDefs.push_back(&func);
            }
        }
    }
 
    for (const Function* func: candidateDefs)
    {
        addFunctionSet(func);
    }
    for (const Function* func: candidateDecls)
    {
        addFunctionSet(func);
    }
 
    // set function exit block
    for (const auto& func: funSet)
    {
        for (Function::const_iterator bit = func->begin(), ebit = func->end(); bit != ebit; ++bit)
        {
            const BasicBlock* bb = &*bit;
            if (succ_size(bb) == 0)
            {
                if (LLVMUtil::basicBlockHasRetInst(bb))
                {
                    assert((LLVMUtil::functionDoesNotRet(func) ||
                            SVFUtil::isa<ReturnInst>(bb->back())) &&
                           "last inst must be return inst");
                    setFunExitBB(func, bb);
                }
            }
        }
        // For no return functions, we set the last block as exit BB
        // This ensures that each function that has definition must have an exit BB
        if (func->size() != 0 && !getFunExitBB(func))
        {
            assert((LLVMUtil::functionDoesNotRet(func) ||
                    SVFUtil::isa<ReturnInst>(&func->back().back())) &&
                   "last inst must be return inst");
            setFunExitBB(func, &func->back());
        }
    }
 
    // Store annotations of functions in extapi.bc
    for (const auto& pair : ExtFun2Annotations)
    {
        const Function* fun = getFunction(pair.first);
        setExtFuncAnnotations(fun, pair.second);
    }
 
}

dumpModulesToFile()

void LLVMModuleSet::dumpModulesToFile

(

const std::string &

suffix

)

Definition at line 1047 of file LLVMModule.cpp.

{
    for (Module& mod : modules)
    {
        std::string moduleName = mod.getName().str();
        std::string OutputFilename;
        std::size_t pos = moduleName.rfind('.');
        if (pos != std::string::npos)
            OutputFilename = moduleName.substr(0, pos) + suffix;
        else
            OutputFilename = moduleName + suffix;
 
        std::error_code EC;
        raw_fd_ostream OS(OutputFilename.c_str(), EC, llvm::sys::fs::OF_None);
        WriteBitcodeToFile(mod, OS);
        OS.flush();
    }
}

dumpSymTable()

void LLVMModuleSet::dumpSymTable

(

)

Definition at line 1103 of file LLVMModule.cpp.

{
    OrderedMap<NodeID, const Value*> idmap;
    for (ValueToIDMapTy::iterator iter = valSymMap.begin(); iter != valSymMap.end();
            ++iter)
    {
        const NodeID i = iter->second;
        idmap[i] = iter->first;
    }
    for (ValueToIDMapTy::iterator iter = objSymMap.begin(); iter != objSymMap.end();
            ++iter)
    {
        const NodeID i = iter->second;
        idmap[i] = iter->first;
    }
    for (FunToIDMapTy::iterator iter = retSyms().begin(); iter != retSyms().end();
            ++iter)
    {
        const NodeID i = iter->second;
        idmap[i] = iter->first;
    }
    for (FunToIDMapTy::iterator iter = varargSyms().begin(); iter != varargSyms().end();
            ++iter)
    {
        const NodeID i = iter->second;
        idmap[i] = iter->first;
    }
    SVFUtil::outs() << "{SymbolTableInfo \n";
 
 
 
 
    for (auto iter : idmap)
    {
        std::string str;
        llvm::raw_string_ostream rawstr(str);
        auto llvmVal = iter.second;
        if (llvmVal)
            rawstr << " " << *llvmVal << " ";
        else
            rawstr << " No llvmVal found";
        rawstr << LLVMUtil::getSourceLoc(llvmVal);
        SVFUtil::outs() << iter.first << " " << rawstr.str() << "\n";
    }
    SVFUtil::outs() << "}\n";
}

empty()

bool SVF::LLVMModuleSet::empty ( ) const

inline

Definition at line 399 of file LLVMModule.h.

    {
        return getModuleNum() == 0;
    }

get_alloc_arg_pos()

s32_t LLVMModuleSet::get_alloc_arg_pos

(

const Function *

F

)

Definition at line 1569 of file LLVMModule.cpp.

{
    std::string allocArg = getExtFuncAnnotation(F, "ALLOC_HEAP_ARG");
    assert(!allocArg.empty() && "Not an alloc call via argument or incorrect extern function annotation!");
 
    std::string number;
    for (char c : allocArg)
    {
        if (isdigit(c))
            number.push_back(c);
    }
    assert(!number.empty() && "Incorrect naming convention for svf external functions(ALLOC_HEAP_ARG + number)?");
    return std::stoi(number);
}

getCallBlock()

CallICFGNode * SVF::LLVMModuleSet::getCallBlock ( const Instruction * cs )

inlineprivate

Get/Add a call node.

Definition at line 495 of file LLVMModule.h.

    {
        CSToCallNodeMapTy::const_iterator it = CSToCallNodeMap.find(cs);
        if (it == CSToCallNodeMap.end())
            return nullptr;
        return it->second;
    }

getCallICFGNode()

CallICFGNode * LLVMModuleSet::getCallICFGNode

(

const Instruction *

cs

)

get a call node

Definition at line 1231 of file LLVMModule.cpp.

{
    assert(LLVMUtil::isCallSite(inst) && "not a call instruction?");
    assert(LLVMUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
    CallICFGNode* node = getCallBlock(inst);
    assert (node!=nullptr && "no CallICFGNode for this instruction?");
    return node;
}

getContext()

LLVMContext & SVF::LLVMModuleSet::getContext ( ) const

inline

Definition at line 393 of file LLVMModule.h.

    {
        assert(!empty() && "empty LLVM module!!");
        return getMainLLVMModule()->getContext();
    }

getDomTree()

DominatorTree & LLVMModuleSet::getDomTree

(

const Function *

fun

)

Definition at line 101 of file LLVMModule.cpp.

{
    auto it = FunToDominatorTree.find(fun);
    if(it != FunToDominatorTree.end()) return it->second;
    DominatorTree& dt = FunToDominatorTree[fun];
    dt.recalculate(const_cast<Function&>(*fun));
    return dt;
}

getExtFuncAnnotation()

std::string LLVMModuleSet::getExtFuncAnnotation	(	const Function *	fun,
		const std::string &	funcAnnotation )

Definition at line 1518 of file LLVMModule.cpp.

{
    assert(fun && "Null Function* pointer");
    auto it = func2Annotations.find(fun);
    if (it != func2Annotations.end())
    {
        for (const std::string& annotation : it->second)
            if (annotation.find(funcAnnotation) != std::string::npos)
                return annotation;
    }
    return "";
}

getExtFuncAnnotations()

const std::vector< std::string > & LLVMModuleSet::getExtFuncAnnotations

(

const Function *

fun

)

Definition at line 1531 of file LLVMModule.cpp.

{
    assert(fun && "Null Function* pointer");
    auto it = func2Annotations.find(fun);
    if (it != func2Annotations.end())
        return it->second;
    return func2Annotations[fun];
}

getFunction()

const Function * SVF::LLVMModuleSet::getFunction ( const std::string & name )

inline

Get the corresponding Function based on its name.

Definition at line 313 of file LLVMModule.h.

    {
        Function* fun = nullptr;
 
        for (u32_t i = 0; i < llvmModuleSet->getModuleNum(); ++i)
        {
            Module* mod = llvmModuleSet->getModule(i);
            fun = mod->getFunction(name);
            if (fun)
            {
                return fun;
            }
        }
        return nullptr;
    }

getFunctionSet()

const FunctionSet & SVF::LLVMModuleSet::getFunctionSet ( ) const

inline

Definition at line 199 of file LLVMModule.h.

    {
        return funSet;
    }

getFunEntryBlock()

FunEntryICFGNode * SVF::LLVMModuleSet::getFunEntryBlock ( const Function * fun )

inlineprivate

Get/Add a function entry node.

Definition at line 521 of file LLVMModule.h.

    {
        FunToFunEntryNodeMapTy::const_iterator it = FunToFunEntryNodeMap.find(fun);
        if (it == FunToFunEntryNodeMap.end())
            return nullptr;
        return it->second;
    }

getFunEntryICFGNode()

FunEntryICFGNode * SVF::LLVMModuleSet::getFunEntryICFGNode ( const Function * fun )

inline

Add a function entry node.

Definition at line 344 of file LLVMModule.h.

    {
        FunEntryICFGNode* b = getFunEntryBlock(fun);
        assert(b && "Function entry not created?");
        return b;
    }

getFunExitBB()

const BasicBlock * SVF::LLVMModuleSet::getFunExitBB ( const Function * fun ) const

inline

Definition at line 185 of file LLVMModule.h.

    {
        auto it = funToExitBB.find(fun);
        if (it == funToExitBB.end()) return nullptr;
        else return it->second;
    }

getFunExitBlock()

FunExitICFGNode * SVF::LLVMModuleSet::getFunExitBlock ( const Function * fun )

inlineprivate

Get/Add a function exit node.

Definition at line 530 of file LLVMModule.h.

    {
        FunToFunExitNodeMapTy::const_iterator it = FunToFunExitNodeMap.find(fun);
        if (it == FunToFunExitNodeMap.end())
            return nullptr;
        return it->second;
    }

getFunExitICFGNode()

FunExitICFGNode * SVF::LLVMModuleSet::getFunExitICFGNode ( const Function * fun )

inline

Add a function exit node.

Definition at line 351 of file LLVMModule.h.

    {
        FunExitICFGNode* b = getFunExitBlock(fun);
        assert(b && "Function exit not created?");
        return b;
    }

getFunObjVar() [1/2]

const FunObjVar * SVF::LLVMModuleSet::getFunObjVar ( const Function * fun ) const

inline

Definition at line 274 of file LLVMModule.h.

    {
        LLVMFun2FunObjVarMap::const_iterator it = LLVMFun2FunObjVar.find(fun);
        assert(it!=LLVMFun2FunObjVar.end() && "SVF Function not found!");
        return it->second;
    }

getFunObjVar() [2/2]

const FunObjVar * LLVMModuleSet::getFunObjVar

(

const std::string &

name

)

Get the corresponding Function based on its name.

Definition at line 1158 of file LLVMModule.cpp.

{
    Function* fun = nullptr;
 
    for (u32_t i = 0; i < llvmModuleSet->getModuleNum(); ++i)
    {
        Module* mod = llvmModuleSet->getModule(i);
        fun = mod->getFunction(name);
        if (fun)
        {
            return llvmModuleSet->getFunObjVar(fun);
        }
    }
    return nullptr;
}

getGlobalRep()

GlobalVariable * SVF::LLVMModuleSet::getGlobalRep ( const GlobalVariable * val ) const

inline

Definition at line 366 of file LLVMModule.h.

    {
        GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
        assert(it != GlobalDefToRepMap.end() && "has no rep?");
        return it->second;
    }

getICFGNode()

ICFGNode * LLVMModuleSet::getICFGNode

(

const Instruction *

inst

)

Get a basic block ICFGNode.

Definition at line 1204 of file LLVMModule.cpp.

{
    ICFGNode* node;
    if(LLVMUtil::isNonInstricCallSite(inst))
        node = getCallICFGNode(inst);
    else if(LLVMUtil::isIntrinsicInst(inst))
        node = getIntraICFGNode(inst);
    else
        node = getIntraICFGNode(inst);
 
    assert (node!=nullptr && "no ICFGNode for this instruction?");
    return node;
}

getIntraBlock()

IntraICFGNode * SVF::LLVMModuleSet::getIntraBlock ( const Instruction * inst )

inlineprivate

Definition at line 512 of file LLVMModule.h.

    {
        InstToBlockNodeMapTy::const_iterator it = InstToBlockNodeMap.find(inst);
        if (it == InstToBlockNodeMap.end())
            return nullptr;
        return it->second;
    }

getIntraICFGNode()

IntraICFGNode * LLVMModuleSet::getIntraICFGNode

(

const Instruction *

inst

)

get a intra node

Definition at line 1249 of file LLVMModule.cpp.

{
    IntraICFGNode* node = getIntraBlock(inst);
    assert (node!=nullptr && "no IntraICFGNode for this instruction?");
    return node;
}

getLLVMGlobalFunctions()

std::vector< const Function * > LLVMModuleSet::getLLVMGlobalFunctions ( const GlobalVariable * global )

private

Definition at line 421 of file LLVMModule.cpp.

{
    // This function is used to extract constructor and destructor functions
    // sorted by their priority from @llvm.global_ctors or @llvm.global_dtors.
    // For example, given following @llvm.global_ctors, the returning sorted
    // function list should be [ctor3, ctor1, ctor2].
    // ------------------------------------------------------------------
    //    ; Each struct in the array is {priority, function, associated data}
    //
    //    @llvm.global_ctors = appending global [2 x { i32, void ()*, i8* }]
    //    [{ i32, void ()*, i8* } { i32 1234, void ()* @ctor1.cpp, i8* null },
    //    { i32, void ()*, i8* } { i32 2345, void ()* @ctor2.cpp, i8* null },
    //    { i32, void ()*, i8* } { i32 345, void ()* @ctor3.cpp, i8* null }]
    // ------------------------------------------------------------------
    // TODO: According to LLVM language reference, if the third field is
    // non-null, and points to a global variable or function, the initializer
    // function will only run if the associated data from the current module is
    // not discarded. However the associated data is currently ignored.
 
 
    // This class is used for the priority queue that sorts the functions by
    // their priority. Each object of this class stands for an item in the
    // function array.
    class LLVMGlobalFunction
    {
    public:
        u32_t priority;
        const Function* func;
        LLVMGlobalFunction() {};
        LLVMGlobalFunction(u32_t _priority, const Function* _func)
            : priority(_priority), func(_func) {};
        bool operator>(const LLVMGlobalFunction &other) const
        {
            if (priority != other.priority)
            {
                return priority > other.priority;
            }
            else
            {
                return func > other.func;
            }
        }
    };
 
    std::priority_queue<LLVMGlobalFunction, std::vector<LLVMGlobalFunction>,
        greater<LLVMGlobalFunction>>
        queue;
    std::vector<const Function* > result;
 
    // The @llvm.global_ctors/dtors global variable is an array of struct. Each
    // struct has three fields: {i32 priority, void ()* @ctor/dtor, i8* @data}.
    // First get the array here.
    if(const ConstantArray *globalFuncArray =
                SVFUtil::dyn_cast<ConstantArray>(global->getInitializer()))
    {
        // Get each struct in the array.
        for (unsigned int i = 0; i < globalFuncArray->getNumOperands(); ++i)
        {
            if (
                const ConstantStruct *globalFuncItem =
                    SVFUtil::dyn_cast<ConstantStruct>(
                        globalFuncArray->getOperand(i)))
            {
 
                // Extract priority and function from the struct
                const ConstantInt* priority = SVFUtil::dyn_cast<ConstantInt>(
                                                  globalFuncItem->getOperand(0));
                const Function* func = SVFUtil::dyn_cast<Function>(
                                           globalFuncItem->getOperand(1));
 
                if (priority && func)
                {
                    queue.push(LLVMGlobalFunction(LLVMUtil::getIntegerValue(priority).second,
                                                  func));
                }
            }
        }
    }
 
    // Generate a sorted vector of functions from the priority queue.
    while (!queue.empty())
    {
        result.push_back(queue.top().func);
        queue.pop();
    }
    return result;
}

getLLVMModules()

const std::vector< std::reference_wrapper< Module > > & SVF::LLVMModuleSet::getLLVMModules ( ) const

inline

Definition at line 164 of file LLVMModule.h.

    {
        return modules;
    }

getLLVMModuleSet()

LLVMModuleSet * SVF::LLVMModuleSet::getLLVMModuleSet ( )

inlinestatic

Definition at line 137 of file LLVMModule.h.

    {
        if (!llvmModuleSet)
            llvmModuleSet = new LLVMModuleSet;
        return llvmModuleSet;
    }

getLLVMType()

const Type * LLVMModuleSet::getLLVMType

(

const SVFType *

T

)

const

Get LLVM Type.

Definition at line 1175 of file LLVMModule.cpp.

{
    for(LLVMType2SVFTypeMap::const_iterator it = LLVMType2SVFType.begin(), eit = LLVMType2SVFType.end(); it!=eit; ++it)
    {
        if (it->second == T)
            return it->first;
    }
    assert(false && "can't find the corresponding LLVM Type");
    abort();
}

getLLVMValue()

const Value * SVF::LLVMModuleSet::getLLVMValue ( const SVFValue * value ) const

inline

Definition at line 267 of file LLVMModule.h.

    {
        SVFBaseNode2LLVMValueMap ::const_iterator it = SVFBaseNode2LLVMValue.find(value);
        assert(it != SVFBaseNode2LLVMValue.end() && "can't find corresponding llvm value!");
        return it->second;
    }

getMainLLVMModule()

Module * SVF::LLVMModuleSet::getMainLLVMModule ( ) const

inline

Definition at line 373 of file LLVMModule.h.

    {
        assert(!empty() && "empty LLVM module!!");
        for (size_t i = 0; i < getModuleNum(); ++i)
        {
            Module& module = getModuleRef(i);
            if (module.getName().str() != ExtAPI::getExtAPI()->getExtBcPath())
            {
                return &module;
            }
        }
        assert(false && "no main module found!");
        return nullptr;
    }

getModule()

Module * SVF::LLVMModuleSet::getModule ( u32_t idx ) const

inline

Definition at line 169 of file LLVMModule.h.

    {
        return &getModuleRef(idx);
    }

getModuleNum()

u32_t SVF::LLVMModuleSet::getModuleNum ( ) const

inline

Definition at line 159 of file LLVMModule.h.

    {
        return modules.size();
    }

getModuleRef()

Module & SVF::LLVMModuleSet::getModuleRef ( u32_t idx ) const

inline

Definition at line 174 of file LLVMModule.h.

    {
        assert(idx < getModuleNum() && "Out of range.");
        return modules[idx];
    }

getObjectNode()

NodeID LLVMModuleSet::getObjectNode

(

const Value *

V

)

getObject - Return the obj node id refer to the memory object for the specified global, heap or alloca instruction according to llvm value.

Definition at line 1093 of file LLVMModule.cpp.

{
    if (const GlobalVariable* glob = SVFUtil::dyn_cast<GlobalVariable>(llvm_value))
        llvm_value = LLVMUtil::getGlobalRep(glob);
    ValueToIDMapTy::const_iterator iter = objSymMap.find(llvm_value);
    assert(iter!=objSymMap.end() && "obj sym not found");
    return iter->second;
}

getObjNodeNum()

u32_t SVF::LLVMModuleSet::getObjNodeNum ( ) const

inline

Definition at line 209 of file LLVMModule.h.

    {
        return objSymMap.size();
    }

getRealDefFun()

const Function * SVF::LLVMModuleSet::getRealDefFun ( const Function * fun ) const

inline

Definition at line 192 of file LLVMModule.h.

    {
        auto it = funToRealDefFun.find(fun);
        if (it == funToRealDefFun.end()) return nullptr;
        else return it->second;
    }

getRetBlock()

RetICFGNode * SVF::LLVMModuleSet::getRetBlock ( const Instruction * cs )

inlineprivate

Get/Add a return node.

Definition at line 504 of file LLVMModule.h.

    {
        CSToRetNodeMapTy::const_iterator it = CSToRetNodeMap.find(cs);
        if (it == CSToRetNodeMap.end())
            return nullptr;
        return it->second;
    }

getRetICFGNode()

RetICFGNode * LLVMModuleSet::getRetICFGNode

(

const Instruction *

cs

)

get a return node

Definition at line 1240 of file LLVMModule.cpp.

{
    assert(LLVMUtil::isCallSite(inst) && "not a call instruction?");
    assert(LLVMUtil::isNonInstricCallSite(inst) && "associating an intrinsic debug instruction with an ICFGNode!");
    RetICFGNode* node = getRetBlock(inst);
    assert (node!=nullptr && "no RetICFGNode for this instruction?");
    return node;
}

getReturnNode()

NodeID SVF::LLVMModuleSet::getReturnNode ( const Function * func ) const

inline

Definition at line 291 of file LLVMModule.h.

    {
        FunToIDMapTy::const_iterator iter =  returnSymMap.find(func);
        assert(iter!=returnSymMap.end() && "ret sym not found");
        return iter->second;
    }

getSVFBasicBlock()

SVFBasicBlock * SVF::LLVMModuleSet::getSVFBasicBlock ( const BasicBlock * bb )

inline

Definition at line 305 of file LLVMModule.h.

    {
        LLVMBB2SVFBBMap::const_iterator it = LLVMBB2SVFBB.find(bb);
        assert(it!=LLVMBB2SVFBB.end() && "SVF BasicBlock not found!");
        return it->second;
    }

getSVFType()

SVFType * LLVMModuleSet::getSVFType

(

const Type *

T

)

Get or create SVFType and typeinfo.

Get or create SVFType and typeinfo

Definition at line 1189 of file LLVMModule.cpp.

{
    assert(T && "SVFType should not be null");
    LLVMType2SVFTypeMap::const_iterator it = LLVMType2SVFType.find(T);
    if (it != LLVMType2SVFType.end())
        return it->second;
 
    SVFType* svfType = addSVFTypeInfo(T);
    StInfo* stinfo = collectTypeInfo(T);
    svfType->setTypeInfo(stinfo);
    return svfType;
}

getTargetABI()

TargetABI SVF::LLVMModuleSet::getTargetABI ( ) const

inline

Definition at line 388 of file LLVMModule.h.

    {
        return targetABI;
    }

getTypeInference()

ObjTypeInference * LLVMModuleSet::getTypeInference

(

)

Definition at line 96 of file LLVMModule.cpp.

{
    return typeInference;
}

getValueNode()

NodeID LLVMModuleSet::getValueNode

(

const Value *

V

)

Get SVFIR Node according to LLVM value getNode - Return the node corresponding to the specified pointer.

Definition at line 1066 of file LLVMModule.cpp.

{
    if (SVFUtil::isa<ConstantPointerNull>(llvm_value))
        return svfir->nullPtrSymID();
    else if (SVFUtil::isa<UndefValue>(llvm_value))
    {
        // For phi ptr [ @x, ... ], [ undef, ... ], keep @x without adding
        // a black-hole target. Integer and aggregate undef keep their model.
        if (Options::UndefAsNull() && llvm_value->getType()->isPointerTy())
            return svfir->nullPtrSymID();
        return svfir->blkPtrSymID();
    }
    else
    {
        ValueToIDMapTy::const_iterator iter = valSymMap.find(llvm_value);
        assert(iter!=valSymMap.end() &&"value sym not found");
        return iter->second;
    }
}

getValueNodeNum()

u32_t SVF::LLVMModuleSet::getValueNodeNum ( ) const

inline

Definition at line 204 of file LLVMModule.h.

    {
        return valSymMap.size();
    }

getVarargNode()

NodeID SVF::LLVMModuleSet::getVarargNode ( const Function * func ) const

inline

Definition at line 298 of file LLVMModule.h.

    {
        FunToIDMapTy::const_iterator iter =  varargSymMap.find(func);
        assert(iter!=varargSymMap.end() && "vararg sym not found");
        return iter->second;
    }

has_static()

bool SVF::LLVMModuleSet::has_static

(

const Function *

F

)

hasExtFuncAnnotation()

bool LLVMModuleSet::hasExtFuncAnnotation	(	const Function *	fun,
		const std::string &	funcAnnotation )

Definition at line 1505 of file LLVMModule.cpp.

{
    assert(fun && "Null SVFFunction* pointer");
    auto it = func2Annotations.find(fun);
    if (it != func2Annotations.end())
    {
        for (const std::string& annotation : it->second)
            if (annotation.find(funcAnnotation) != std::string::npos)
                return true;
    }
    return false;
}

hasGlobalRep()

bool SVF::LLVMModuleSet::hasGlobalRep ( const GlobalVariable * val ) const

inline

Global to rep.

Definition at line 360 of file LLVMModule.h.

    {
        GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
        return it != GlobalDefToRepMap.end();
    }

hasICFGNode()

bool LLVMModuleSet::hasICFGNode

(

const Instruction *

inst

)

Definition at line 1218 of file LLVMModule.cpp.

{
    ICFGNode* node;
    if(LLVMUtil::isNonInstricCallSite(inst))
        node = getCallBlock(inst);
    else if(LLVMUtil::isIntrinsicInst(inst))
        node = getIntraBlock(inst);
    else
        node = getIntraBlock(inst);
 
    return node != nullptr;
}

hasLLVMValue()

bool SVF::LLVMModuleSet::hasLLVMValue ( const SVFValue * value ) const

inline

Definition at line 262 of file LLVMModule.h.

    {
        return SVFBaseNode2LLVMValue.find(value) != SVFBaseNode2LLVMValue.end();
    }

hasValueNode()

bool LLVMModuleSet::hasValueNode

(

const Value *

V

)

Definition at line 1085 of file LLVMModule.cpp.

{
    if (SVFUtil::isa<ConstantPointerNull, UndefValue>(val))
        return true;
    else
        return (valSymMap.find(val) != valSymMap.end());
}

is_alloc()

bool LLVMModuleSet::is_alloc

(

const Function *

F

)

Definition at line 1552 of file LLVMModule.cpp.

{
    return F && hasExtFuncAnnotation(F, "ALLOC_HEAP_RET");
}

is_alloc_stack_ret()

bool LLVMModuleSet::is_alloc_stack_ret

(

const Function *

F

)

Definition at line 1563 of file LLVMModule.cpp.

{
    return F && hasExtFuncAnnotation(F, "ALLOC_STACK_RET");
}

is_arg_alloc()

bool LLVMModuleSet::is_arg_alloc

(

const Function *

F

)

Definition at line 1558 of file LLVMModule.cpp.

{
    return F && hasExtFuncAnnotation(F, "ALLOC_HEAP_ARG");
}

is_ext()

bool LLVMModuleSet::is_ext

(

const Function *

F

)

Definition at line 1593 of file LLVMModule.cpp.

{
    assert(F && "Null SVFFunction* pointer");
    if (F->isDeclaration() || F->isIntrinsic())
        return true;
    else if (hasExtFuncAnnotation(F, "OVERWRITE") && getExtFuncAnnotations(F).size() == 1)
        return false;
    else
        return !getExtFuncAnnotations(F).empty();
}

is_memcpy()

bool LLVMModuleSet::is_memcpy

(

const Function *

F

)

Definition at line 1540 of file LLVMModule.cpp.

{
    return F &&
           (hasExtFuncAnnotation(F, "MEMCPY") ||  hasExtFuncAnnotation(F, "STRCPY")
            || hasExtFuncAnnotation(F, "STRCAT"));
}

is_memset()

bool LLVMModuleSet::is_memset

(

const Function *

F

)

Definition at line 1547 of file LLVMModule.cpp.

{
    return F && hasExtFuncAnnotation(F, "MEMSET");
}

is_realloc()

bool LLVMModuleSet::is_realloc

(

const Function *

F

)

Definition at line 1585 of file LLVMModule.cpp.

{
    return F && hasExtFuncAnnotation(F, "REALLOC_HEAP_RET");
}

loadExtAPIModules()

void LLVMModuleSet::loadExtAPIModules ( )

private

Definition at line 382 of file LLVMModule.cpp.

{
    // This function loads the ExtAPI bitcode file as an LLVM module. Note that it is important that
    // the same LLVMContext object is used to load this bitcode file as is used by the other modules
    // being analysed.
    // When the modules are loaded from bitcode files (i.e. passing filenames to files containing
    // LLVM IR to `buildSVFModule({file1.bc, file2.bc, ...})) the context is created while loading
    // the modules in `loadModules()`, which populates this->modules and this->owned_modules.
    // If, however, an LLVM Module object is passed to `buildSVFModule` (e.g. from an LLVM pass),
    // the context should be retrieved from the module itself (note that the garbage collection from
    // `std::unique_ptr<LLVMContext> LLVMModuleSet::owned_ctx` should be avoided in this case). This
    // function populates only this->modules.
    // In both cases, fetching the context from the main LLVM module (through `getContext`) works
    assert(!empty() && "LLVMModuleSet contains no modules; cannot load ExtAPI module without LLVMContext!");
 
    // Load external API module (extapi.bc)
    if (!ExtAPI::getExtAPI()->getExtBcPath().empty())
    {
        std::string extModuleName = ExtAPI::getExtAPI()->getExtBcPath();
        if (!LLVMUtil::isIRFile(extModuleName))
        {
            SVFUtil::errs() << "not an external IR file: " << extModuleName << std::endl;
            abort();
        }
        SMDiagnostic Err;
        std::unique_ptr<Module> mod = parseIRFile(extModuleName, Err, getContext());
        if (mod == nullptr)
        {
            SVFUtil::errs() << "load external module: " << extModuleName << "failed!!\n\n";
            Err.print("SVFModuleLoader", llvm::errs());
            abort();
        }
        // The module of extapi.bc needs to be inserted before applications modules, like std::vector<std::reference_wrapper<Module>> modules{extapi_module, app_module}.
        // Otherwise, when overwriting the app function with SVF extern function, the corresponding SVFFunction of the extern function will not be found.
        modules.insert(modules.begin(), *mod);
        owned_modules.insert(owned_modules.begin(),std::move(mod));
    }
}

loadModules()

void LLVMModuleSet::loadModules ( const std::vector< std::string > & moduleNameVec )

private

Definition at line 316 of file LLVMModule.cpp.

{
 
    // We read SVFIR from LLVM IR
    if(Options::Graphtxt().empty())
    {
        if(moduleNameVec.empty())
        {
            SVFUtil::outs() << "no LLVM bc file is found!\n";
            exit(0);
        }
        //assert(!moduleNameVec.empty() && "no LLVM bc file is found!");
    }
    // We read SVFIR from a user-defined txt instead of parsing SVFIR from LLVM IR
    else
    {
        SVFIR::setPagFromTXT(Options::Graphtxt());
    }
    //
    // LLVMContext objects separate global LLVM settings (from which e.g. types are
    // derived); multiple LLVMContext objects can coexist and each context can "own"
    // multiple modules (modules can only have one context). Mixing contexts can lead
    // to unintended inequalities, such as the following:
    //
    // ------------------------------------------------------------------
    //    LLVMContext ctxa,ctxb;
    //    IntegerType * t1 = IntegerType::get(ctxa,32);
    //    IntegerType * t2 = IntegerType::get(ctxa,32);
    //    assert(t1 == t2);
    //    IntegerType * t3 = IntegerType::get(ctxb,32);
    //    IntegerType * t4 = IntegerType::get(ctxb,32);
    //    assert(t3 == t4);
    //    assert(t1 != t3);
    // ------------------------------------------------------------------
    //
    // When loading bytecode files, SVF will use the same LLVMContext object for all
    // modules (i.e. the context owns all loaded modules). This applies to ExtAPI as
    // well, which *must* be loaded using the same LLVMContext object. Hence, when
    // loading modules from bitcode files, a new LLVMContext is created (using a
    // `std::unique_ptr<LLVMContext>` type to ensure automatic garbage collection).
    //
    // This garbage collection should be avoided when building an SVF module from an LLVM
    // module instance; see the comment(s) in `buildSVFModule` and `loadExtAPIModules()`
 
    owned_ctx = std::make_unique<LLVMContext>();
    for (const std::string& moduleName : moduleNameVec)
    {
        if (!LLVMUtil::isIRFile(moduleName))
        {
            SVFUtil::errs() << "not an IR file: " << moduleName << std::endl;
            abort();
        }
 
        SMDiagnostic Err;
        std::unique_ptr<Module> mod = parseIRFile(moduleName, Err, *owned_ctx);
        if (mod == nullptr)
        {
            SVFUtil::errs() << "load module: " << moduleName << "failed!!\n\n";
            Err.print("SVFModuleLoader", llvm::errs());
            abort();
        }
        modules.emplace_back(*mod);
        owned_modules.emplace_back(std::move(mod));
    }
}

objSyms()

ValueToIDMapTy & SVF::LLVMModuleSet::objSyms ( )

inline

Definition at line 219 of file LLVMModule.h.

    {
        return objSymMap;
    }

prePassSchedule()

void LLVMModuleSet::prePassSchedule ( )

private

Invoke llvm passes to modify module.

Invoke llvm passes to modify module

BreakConstantGEPs Pass

MergeFunctionRets Pass

Definition at line 259 of file LLVMModule.cpp.

{
    std::unique_ptr<BreakConstantGEPs> p1 = std::make_unique<BreakConstantGEPs>();
    for (Module &M : getLLVMModules())
    {
        p1->runOnModule(M);
    }

    std::unique_ptr<UnifyFunctionExitNodes> p2 =
        std::make_unique<UnifyFunctionExitNodes>();
    for (Module &M : getLLVMModules())
    {
        for (auto F = M.begin(), E = M.end(); F != E; ++F)
        {
            Function &fun = *F;
            if (fun.isDeclaration())
                continue;
            llvm::PassBuilder PB;
            llvm::LoopAnalysisManager LAM;
            llvm::FunctionAnalysisManager FAM;
            llvm::CGSCCAnalysisManager CGAM;
            llvm::ModuleAnalysisManager MAM;
            PB.registerModuleAnalyses(MAM);
            PB.registerCGSCCAnalyses(CGAM);
            PB.registerFunctionAnalyses(FAM);
            PB.registerLoopAnalyses(LAM);
            PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
            llvm::FunctionPassManager FPM;
            FPM.addPass(llvm::UnifyFunctionExitNodesPass());
            FPM.run(fun, FAM);
        }
    }
}

preProcessBCs()

void LLVMModuleSet::preProcessBCs ( std::vector< std::string > & moduleNameVec )

static

Definition at line 295 of file LLVMModule.cpp.

{
    LLVMModuleSet* mset = getLLVMModuleSet();
    mset->loadModules(moduleNameVec);
    mset->loadExtAPIModules();
    mset->prePassSchedule();
 
    std::string preProcessSuffix = ".pre.bc";
    // Get the existing module names, remove old extension, add preProcessSuffix
    for (u32_t i = 0; i < moduleNameVec.size(); i++)
    {
        u32_t lastIndex = moduleNameVec[i].find_last_of(".");
        std::string rawName = moduleNameVec[i].substr(0, lastIndex);
        moduleNameVec[i] = (rawName + preProcessSuffix);
    }
 
    mset->dumpModulesToFile(preProcessSuffix);
    preProcessed = true;
    releaseLLVMModuleSet();
}

releaseLLVMModuleSet()

void SVF::LLVMModuleSet::releaseLLVMModuleSet ( )

inlinestatic

Definition at line 144 of file LLVMModule.h.

    {
        delete llvmModuleSet;
        llvmModuleSet = nullptr;
        NodeIDAllocator::unset();
    }

retSyms()

FunToIDMapTy & SVF::LLVMModuleSet::retSyms ( )

inline

Definition at line 281 of file LLVMModule.h.

    {
        return returnSymMap;
    }

setExtFuncAnnotations()

void LLVMModuleSet::setExtFuncAnnotations	(	const Function *	fun,
		const std::vector< std::string > &	funcAnnotations )

Definition at line 1499 of file LLVMModule.cpp.

{
    assert(fun && "Null SVFFunction* pointer");
    func2Annotations[fun] = funcAnnotations;
}

setFunExitBB()

void SVF::LLVMModuleSet::setFunExitBB ( const Function * fun, const BasicBlock * bb )

inlineprivate

Definition at line 457 of file LLVMModule.h.

    {
        funToExitBB[fun] = bb;
    }

setFunRealDefFun()

void SVF::LLVMModuleSet::setFunRealDefFun ( const Function * fun, const Function * realDefFun )

inlineprivate

Definition at line 462 of file LLVMModule.h.

    {
        funToRealDefFun[fun] = realDefFun;
    }

valSyms()

ValueToIDMapTy & SVF::LLVMModuleSet::valSyms ( )

inline

Definition at line 214 of file LLVMModule.h.

    {
        return valSymMap;
    }

varargSyms()

FunToIDMapTy & SVF::LLVMModuleSet::varargSyms ( )

inline

Definition at line 286 of file LLVMModule.h.

    {
        return varargSymMap;
    }

Friends And Related Symbol Documentation

ICFGBuilder

friend class ICFGBuilder

friend

Definition at line 50 of file LLVMModule.h.

SVFIRBuilder

friend class SVFIRBuilder

friend

Definition at line 49 of file LLVMModule.h.

SymbolTableBuilder

friend class SymbolTableBuilder

friend

Definition at line 51 of file LLVMModule.h.

Member Data Documentation

CSToCallNodeMap

CSToCallNodeMapTy SVF::LLVMModuleSet::CSToCallNodeMap

private

map a callsite to its CallICFGNode

Definition at line 112 of file LLVMModule.h.

CSToRetNodeMap

CSToRetNodeMapTy SVF::LLVMModuleSet::CSToRetNodeMap

private

map a callsite to its RetICFGNode

Definition at line 113 of file LLVMModule.h.

ExtFun2Annotations

Fun2AnnoMap SVF::LLVMModuleSet::ExtFun2Annotations

private

Record annotations of function in extapi.bc.

Definition at line 97 of file LLVMModule.h.

ExtFuncsVec

FunctionSetType SVF::LLVMModuleSet::ExtFuncsVec

private

Record some "sse_" function declarations used in other ext function definition, e.g., svf_ext_foo(), and svf_ext_foo() used in app functions.

Definition at line 95 of file LLVMModule.h.

func2Annotations

Map<const Function*, std::vector<std::string> > SVF::LLVMModuleSet::func2Annotations

private

Definition at line 100 of file LLVMModule.h.

funSet

FunctionSet SVF::LLVMModuleSet::funSet

private

Definition at line 125 of file LLVMModule.h.

FunToDominatorTree

Map<const Function*, DominatorTree> SVF::LLVMModuleSet::FunToDominatorTree

private

Definition at line 118 of file LLVMModule.h.

funToExitBB

FunToExitBBMap SVF::LLVMModuleSet::funToExitBB

private

Definition at line 126 of file LLVMModule.h.

FunToFunEntryNodeMap

FunToFunEntryNodeMapTy SVF::LLVMModuleSet::FunToFunEntryNodeMap

private

map a function to its FunExitICFGNode

Definition at line 115 of file LLVMModule.h.

FunToFunExitNodeMap

FunToFunExitNodeMapTy SVF::LLVMModuleSet::FunToFunExitNodeMap

private

map a function to its FunEntryICFGNode

Definition at line 116 of file LLVMModule.h.

funToRealDefFun

FunToRealDefFunMap SVF::LLVMModuleSet::funToRealDefFun

private

Definition at line 127 of file LLVMModule.h.

GlobalDefToRepMap

GlobalDefToRepMapTy SVF::LLVMModuleSet::GlobalDefToRepMap

private

Global definition to a rep definition map.

Definition at line 103 of file LLVMModule.h.

InstToBlockNodeMap

InstToBlockNodeMapTy SVF::LLVMModuleSet::InstToBlockNodeMap

private

map a basic block to its ICFGNode

Definition at line 114 of file LLVMModule.h.

LLVMBB2SVFBB

LLVMBB2SVFBBMap SVF::LLVMModuleSet::LLVMBB2SVFBB

private

Definition at line 106 of file LLVMModule.h.

LLVMFun2FunObjVar

LLVMFun2FunObjVarMap SVF::LLVMModuleSet::LLVMFun2FunObjVar

private

Map an LLVM Function to an SVF Funobjvar.

Definition at line 105 of file LLVMModule.h.

llvmModuleSet

LLVMModuleSet * LLVMModuleSet::llvmModuleSet = nullptr

staticprivate

Definition at line 84 of file LLVMModule.h.

LLVMType2SVFType

LLVMType2SVFTypeMap SVF::LLVMModuleSet::LLVMType2SVFType

private

Definition at line 107 of file LLVMModule.h.

modules

std::vector<std::reference_wrapper<Module> > SVF::LLVMModuleSet::modules

private

Definition at line 89 of file LLVMModule.h.

objSymMap

ValueToIDMapTy SVF::LLVMModuleSet::objSymMap

private

map a obj reference to its sym id

Definition at line 121 of file LLVMModule.h.

owned_ctx

std::unique_ptr<LLVMContext> SVF::LLVMModuleSet::owned_ctx

private

Definition at line 87 of file LLVMModule.h.

owned_modules

std::vector<std::unique_ptr<Module> > SVF::LLVMModuleSet::owned_modules

private

Definition at line 88 of file LLVMModule.h.

preProcessed

bool LLVMModuleSet::preProcessed = false

staticprivate

Definition at line 85 of file LLVMModule.h.

returnSymMap

FunToIDMapTy SVF::LLVMModuleSet::returnSymMap

private

return map

Definition at line 122 of file LLVMModule.h.

SVFBaseNode2LLVMValue

SVFBaseNode2LLVMValueMap SVF::LLVMModuleSet::SVFBaseNode2LLVMValue

private

Definition at line 111 of file LLVMModule.h.

svfir

SVFIR* SVF::LLVMModuleSet::svfir

private

Definition at line 86 of file LLVMModule.h.

targetABI

TargetABI SVF::LLVMModuleSet::targetABI = TargetABI::Itanium

private

C++ ABI of the module being analyzed.

Definition at line 92 of file LLVMModule.h.

Type2TypeInfo

Type2TypeInfoMap SVF::LLVMModuleSet::Type2TypeInfo

private

Definition at line 108 of file LLVMModule.h.

typeInference

ObjTypeInference* SVF::LLVMModuleSet::typeInference

private

Definition at line 109 of file LLVMModule.h.

valSymMap

ValueToIDMapTy SVF::LLVMModuleSet::valSymMap

private

map a value to its sym id

Definition at line 120 of file LLVMModule.h.

varargSymMap

FunToIDMapTy SVF::LLVMModuleSet::varargSymMap

private

vararg map

Definition at line 123 of file LLVMModule.h.

---

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

• /home/runner/work/SVF/SVF/svf-llvm/include/SVF-LLVM/LLVMModule.h
• /home/runner/work/SVF/SVF/svf-llvm/lib/LLVMModule.cpp