#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 , SVFFunction >	LLVMFun2SVFFunMap

typedef Map< const Function , CallGraphNode >	LLVMFun2CallGraphNodeMap

typedef Map< const BasicBlock , SVFBasicBlock >	LLVMBB2SVFBBMap

typedef Map< const Instruction , SVFInstruction >	LLVMInst2SVFInstMap

typedef Map< const Argument , SVFArgument >	LLVMArgument2SVFArgumentMap

typedef Map< const Constant , SVFConstant >	LLVMConst2SVFConstMap

typedef Map< const Value , SVFOtherValue >	LLVMValue2SVFOtherValueMap

typedef Map< const SVFValue , const Value >	SVFValue2LLVMValueMap

typedef Map< const SVFBaseNode , 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

Public Member Functions
	~LLVMModuleSet ()

SVFModule *	getSVFModule ()

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)

void	addFunctionMap (const Function func, SVFFunction svfFunc)

void	addFunctionMap (const Function func, CallGraphNode svfFunc)

void	addBasicBlockMap (const BasicBlock bb, SVFBasicBlock svfBB)

void	addInstructionMap (const Instruction inst, SVFInstruction svfInst)

void	addInstructionMap (const Instruction inst, CallICFGNode svfInst)

void	addInstructionMap (const Instruction inst, RetICFGNode svfInst)

void	addInstructionMap (const Instruction inst, IntraICFGNode svfInst)

void	addArgumentMap (const Argument arg, SVFArgument svfArg)

void	addGlobalValueMap (const GlobalValue glob, SVFGlobalValue svfglob)

void	addConstantDataMap (const ConstantData cd, SVFConstantData svfcd)

void	addOtherConstantMap (const Constant cons, SVFConstant svfcons)

void	addOtherValueMap (const Value ov, SVFOtherValue svfov)

SVFValue *	getSVFValue (const Value *value)

const Value *	getLLVMValue (const SVFValue *value) const

const Value *	getLLVMValue (const SVFBaseNode *value) const

CallGraphNode *	getCallGraphNode (const Function *fun) const

SVFFunction *	getSVFFunction (const Function *fun) const

SVFBasicBlock *	getSVFBasicBlock (const BasicBlock *bb) const

SVFInstruction *	getSVFInstruction (const Instruction *inst) const

SVFArgument *	getSVFArgument (const Argument *arg) const

SVFGlobalValue *	getSVFGlobalValue (const GlobalValue *g) const

SVFConstantData *	getSVFConstantData (const ConstantData *cd)

SVFConstant *	getOtherSVFConstant (const Constant *oc)

SVFOtherValue *	getSVFOtherValue (const Value *ov)

const SVFFunction *	getSVFFunction (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

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 ()

ICFG *	getICFG ()

DominatorTree &	getDomTree (const Function *fun)

Static Public Member Functions
static LLVMModuleSet *	getLLVMModuleSet ()

static void	releaseLLVMModuleSet ()

static SVFModule *	buildSVFModule (Module &mod)

static SVFModule *	buildSVFModule (const std::vector< std::string > &moduleNameVec)

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

Private Member Functions
	LLVMModuleSet ()
	Constructor.

void	build ()

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	createSVFFunction (const Function *func)

void	initSVFFunction ()

void	initSVFBasicBlock (const Function *func)

void	initDomTree (SVFFunction func, const Function f)

void	setValueAttr (const Value val, SVFValue value)

void	addToLLVMVal2SVFVarMap (const Value val, SVFBaseNode 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
SymbolTableInfo *	symInfo

SVFModule *	svfModule
	Borrowed from singleton SVFModule::svfModule.

ICFG *	icfg

std::unique_ptr< LLVMContext >	owned_ctx

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

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

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.

GlobalDefToRepMapTy	GlobalDefToRepMap
	Global definition to a rep definition map.

LLVMFun2SVFFunMap	LLVMFunc2SVFFunc
	Map an LLVM Function to an SVF Function.

LLVMFun2CallGraphNodeMap	LLVMFunc2CallGraphNode
	Map an LLVM Function to an CallGraph Node.

LLVMBB2SVFBBMap	LLVMBB2SVFBB

LLVMInst2SVFInstMap	LLVMInst2SVFInst

LLVMArgument2SVFArgumentMap	LLVMArgument2SVFArgument

LLVMConst2SVFConstMap	LLVMConst2SVFConst

LLVMValue2SVFOtherValueMap	LLVMValue2SVFOtherValue

SVFValue2LLVMValueMap	SVFValue2LLVMValue

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

CallGraph *	callgraph

Map< const Function *, DominatorTree >	FunToDominatorTree

Static Private Attributes
static LLVMModuleSet *	llvmModuleSet = nullptr

static bool	preProcessed = false

Friends
class	SVFIRBuilder

class	ICFGBuilder

Detailed Description

Definition at line 44 of file LLVMModule.h.

Member Typedef Documentation

◆ CSToCallNodeMapTy

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

Definition at line 69 of file LLVMModule.h.

◆ CSToRetNodeMapTy

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

Definition at line 70 of file LLVMModule.h.

◆ Fun2AnnoMap

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

Definition at line 67 of file LLVMModule.h.

◆ FunctionSetType

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

Definition at line 51 of file LLVMModule.h.

◆ FunDeclToDefMapTy

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

Definition at line 52 of file LLVMModule.h.

◆ FunDefToDeclsMapTy

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

Definition at line 53 of file LLVMModule.h.

◆ FunToFunEntryNodeMapTy

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

Definition at line 72 of file LLVMModule.h.

◆ FunToFunExitNodeMapTy

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

Definition at line 73 of file LLVMModule.h.

◆ GlobalDefToRepMapTy

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

Definition at line 54 of file LLVMModule.h.

◆ InstToBlockNodeMapTy

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

Definition at line 71 of file LLVMModule.h.

◆ LLVMArgument2SVFArgumentMap

typedef Map<const Argument*, SVFArgument*> SVF::LLVMModuleSet::LLVMArgument2SVFArgumentMap

Definition at line 60 of file LLVMModule.h.

◆ LLVMBB2SVFBBMap

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

Definition at line 58 of file LLVMModule.h.

◆ LLVMConst2SVFConstMap

typedef Map<const Constant*, SVFConstant*> SVF::LLVMModuleSet::LLVMConst2SVFConstMap

Definition at line 61 of file LLVMModule.h.

◆ LLVMFun2CallGraphNodeMap

typedef Map<const Function*, CallGraphNode*> SVF::LLVMModuleSet::LLVMFun2CallGraphNodeMap

Definition at line 57 of file LLVMModule.h.

◆ LLVMFun2SVFFunMap

typedef Map<const Function*, SVFFunction*> SVF::LLVMModuleSet::LLVMFun2SVFFunMap

Definition at line 56 of file LLVMModule.h.

◆ LLVMInst2SVFInstMap

typedef Map<const Instruction*, SVFInstruction*> SVF::LLVMModuleSet::LLVMInst2SVFInstMap

Definition at line 59 of file LLVMModule.h.

◆ LLVMType2SVFTypeMap

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

Definition at line 65 of file LLVMModule.h.

◆ LLVMValue2SVFOtherValueMap

typedef Map<const Value*, SVFOtherValue*> SVF::LLVMModuleSet::LLVMValue2SVFOtherValueMap

Definition at line 62 of file LLVMModule.h.

◆ SVFBaseNode2LLVMValueMap

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

Definition at line 64 of file LLVMModule.h.

◆ SVFValue2LLVMValueMap

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

Definition at line 63 of file LLVMModule.h.

◆ Type2TypeInfoMap

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

Definition at line 66 of file LLVMModule.h.

Constructor & Destructor Documentation

◆ LLVMModuleSet()

LLVMModuleSet::LLVMModuleSet ( )

private

Constructor.

Definition at line 80 of file LLVMModule.cpp.

    : symInfo(SymbolTableInfo::SymbolInfo()),
      svfModule(SVFModule::getSVFModule()), typeInference(new ObjTypeInference())
{
}

◆ ~LLVMModuleSet()

LLVMModuleSet::~LLVMModuleSet ( )

Definition at line 86 of file LLVMModule.cpp.

{
    for (auto& item : LLVMInst2SVFInst)
    {
        delete item.second;
        item.second = nullptr;
    }
    delete typeInference;
    typeInference = nullptr;
}

Member Function Documentation

◆ addArgumentMap()

void SVF::LLVMModuleSet::addArgumentMap	(	const Argument *	arg,
		SVFArgument *	svfArg
	)

inline

Definition at line 206 of file LLVMModule.h.

    {
        LLVMArgument2SVFArgument[arg] = svfArg;
        setValueAttr(arg,svfArg);
    }

◆ addBasicBlockMap()

void SVF::LLVMModuleSet::addBasicBlockMap	(	const BasicBlock *	bb,
		SVFBasicBlock *	svfBB
	)

inline

Definition at line 180 of file LLVMModule.h.

    {
        LLVMBB2SVFBB[bb] = svfBB;
        setValueAttr(bb,svfBB);
    }

◆ addConstantDataMap()

void SVF::LLVMModuleSet::addConstantDataMap	(	const ConstantData *	cd,
		SVFConstantData *	svfcd
	)

inline

Definition at line 221 of file LLVMModule.h.

    {
        LLVMConst2SVFConst[cd] = svfcd;
        setValueAttr(cd,svfcd);
    }

◆ addFunctionMap() [1/2]

void LLVMModuleSet::addFunctionMap	(	const Function *	func,
		CallGraphNode *	svfFunc
	)

Definition at line 1223 of file LLVMModule.cpp.

{
    LLVMFunc2CallGraphNode[func] = svfFunc;
    addToLLVMVal2SVFVarMap(func, svfFunc);
}

◆ addFunctionMap() [2/2]

void SVF::LLVMModuleSet::addFunctionMap	(	const Function *	func,
		SVFFunction *	svfFunc
	)

inline

Definition at line 172 of file LLVMModule.h.

    {
        LLVMFunc2SVFFunc[func] = svfFunc;
        setValueAttr(func,svfFunc);
    }

◆ addGlobalValueMap()

void SVF::LLVMModuleSet::addGlobalValueMap	(	const GlobalValue *	glob,
		SVFGlobalValue *	svfglob
	)

inline

Definition at line 211 of file LLVMModule.h.

    {
        if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(glob);
                hasGlobalRep(glob_var))
        {
            glob = getGlobalRep(glob_var);
        }
        LLVMConst2SVFConst[glob] = svfglob;
        setValueAttr(glob,svfglob);
    }

◆ addInstructionMap() [1/4]

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

inline

Definition at line 190 of file LLVMModule.h.

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

◆ addInstructionMap() [2/4]

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

inline

Definition at line 200 of file LLVMModule.h.

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

◆ addInstructionMap() [3/4]

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

inline

Definition at line 195 of file LLVMModule.h.

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

◆ addInstructionMap() [4/4]

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

inline

Definition at line 185 of file LLVMModule.h.

    {
        LLVMInst2SVFInst[inst] = svfInst;
        setValueAttr(inst,svfInst);
    }

◆ addOtherConstantMap()

void SVF::LLVMModuleSet::addOtherConstantMap	(	const Constant *	cons,
		SVFConstant *	svfcons
	)

inline

Definition at line 226 of file LLVMModule.h.

    {
        LLVMConst2SVFConst[cons] = svfcons;
        setValueAttr(cons,svfcons);
    }

◆ addOtherValueMap()

void SVF::LLVMModuleSet::addOtherValueMap	(	const Value *	ov,
		SVFOtherValue *	svfov
	)

inline

Definition at line 231 of file LLVMModule.h.

    {
        LLVMValue2SVFOtherValue[ov] = svfov;
        setValueAttr(ov,svfov);
    }

◆ addSVFMain()

void LLVMModuleSet::addSVFMain ( )

private

Definition at line 724 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().equals(SVF_GLOBAL_CTORS) && global.hasInitializer())
            {
                ctor_funcs = getLLVMGlobalFunctions(&global);
            }
            else if (global.getName().equals(SVF_GLOBAL_DTORS) && global.hasInitializer())
            {
                dtor_funcs = getLLVMGlobalFunctions(&global);
            }
        }
 
        // Find main function
        for (auto &func : mod)
        {
            auto funName = func.getName();
 
            assert(!funName.equals(SVF_MAIN_FUNC_NAME) && SVF_MAIN_FUNC_NAME " already defined");
 
            if (funName.equals("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**)
#if (LLVM_VERSION_MAJOR >= 9)
        FunctionCallee svfmainFn = M.getOrInsertFunction(
                                       SVF_MAIN_FUNC_NAME,
                                       Type::getVoidTy(M.getContext()),
                                       i32,ptr,ptr
                                   );
        Function* svfmain = SVFUtil::dyn_cast<Function>(svfmainFn.getCallee());
#else
        Function* svfmain = SVFUtil::dyn_cast<Function>(M.getOrInsertFunction(
                                SVF_MAIN_FUNC_NAME,
                                Type::getVoidTy(M.getContext()),
                                i32,i8ptr2,i8ptr2
                            ));
#endif
        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();
    }
}

◆ addSVFTypeInfo()

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

private

Create SVFTypes.

Definition at line 1500 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;
    if (SVFUtil::isa<PointerType>(T))
    {
        svftype = new SVFPointerType(byteSize);
    }
    else if (const IntegerType* intT = SVFUtil::dyn_cast<IntegerType>(T))
    {
        auto svfIntT = new SVFIntegerType(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))
        svftype = new SVFFunctionType(getSVFType(ft->getReturnType()));
    else if (const StructType* st = SVFUtil::dyn_cast<StructType>(T))
    {
        auto svfst = new SVFStructType(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(byteSize);
        svfat->setNumOfElement(at->getNumElements());
        svfat->setTypeOfElement(getSVFType(at->getElementType()));
        svftype = svfat;
    }
    else
    {
        std::string buffer;
        auto ot = new SVFOtherType(T->isSingleValueType(), byteSize);
        llvm::raw_string_ostream(buffer) << *T;
        ot->setRepr(std::move(buffer));
        svftype = ot;
    }
 
    symInfo->addTypeInfo(svftype);
    LLVMType2SVFType[T] = svftype;
 
    return svftype;
}

◆ addToLLVMVal2SVFVarMap()

void LLVMModuleSet::addToLLVMVal2SVFVarMap	(	const Value *	val,
		SVFBaseNode *	svfBaseNode
	)

private

Definition at line 1257 of file LLVMModule.cpp.

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

◆ build()

void LLVMModuleSet::build ( )

private

Definition at line 168 of file LLVMModule.cpp.

{
    if(preProcessed==false)
        prePassSchedule();
 
    buildFunToFunMap();
    buildGlobalDefToRepMap();
 
    if (Options::SVFMain())
        addSVFMain();
 
    createSVFDataStructure();
    initSVFFunction();
 
 
    ICFGBuilder icfgbuilder;
    icfg = icfgbuilder.build();
 
    CallGraphBuilder callGraphBuilder;
    callgraph = callGraphBuilder.buildSVFIRCallGraph(svfModule);
    for (const auto& func : svfModule->getFunctionSet())
    {
        SVFFunction* svffunc = const_cast<SVFFunction*>(func);
        svffunc->setCallGraphNode(callgraph->getCallGraphNode(func));
    }
 
    for (const auto& it : *callgraph)
    {
        addFunctionMap(
            SVFUtil::cast<Function>(getLLVMValue(it.second->getFunction())),
            it.second);
    }
}

◆ 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 886 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();
        }
        // Create a new function with the same signature as extFunToClone
        Function *clonedFunction = Function::Create(extFunToClone->getFunctionType(), Function::ExternalLinkage, extFunToClone->getName(), appModule);
        // 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)
        {
            // Clone the body of extFunToClone into clonedFunction
            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();
            clonedFunction->setName(oldFunctionName);
        }
        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 1155 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]

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

static

Definition at line 128 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())
    {
        SVFModule::getSVFModule()->setModuleIdentifier(moduleNameVec.front());
    }
 
    mset->build();
 
    double endSVFModuleTime = SVFStat::getClk(true);
    SVFStat::timeOfBuildingLLVMModule =
        (endSVFModuleTime - startSVFModuleTime) / TIMEINTERVAL;
 
    mset->buildSymbolTable();
    // Don't releaseLLVMModuleSet() here, as IRBuilder might still need LLVMMoudleSet
    return SVFModule::getSVFModule();
}

◆ buildSVFModule() [2/2]

SVFModule * LLVMModuleSet::buildSVFModule ( Module & mod )

static

Definition at line 111 of file LLVMModule.cpp.

{
    LLVMModuleSet* mset = getLLVMModuleSet();
 
    double startSVFModuleTime = SVFStat::getClk(true);
    SVFModule::getSVFModule()->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();
    // Don't releaseLLVMModuleSet() here, as IRBuilder might still need LLVMMoudleSet
    return SVFModule::getSVFModule();
}

◆ buildSymbolTable()

void LLVMModuleSet::buildSymbolTable ( ) const

private

building symbol table

Definition at line 153 of file LLVMModule.cpp.

{
    double startSymInfoTime = SVFStat::getClk(true);
    if (!SVFModule::pagReadFromTXT())
    {
        DBOUT(DGENERAL, SVFUtil::outs() << SVFUtil::pasMsg("Building Symbol table ...\n"));
        SymbolTableBuilder builder(symInfo);
        builder.buildMemModel(svfModule);
    }
    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 1562 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 818 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 1682 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 1625 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 1468 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 > symInfo->maxStSize)
        {
            symInfo->maxStruct = getSVFType(sty);
            symInfo->maxStSize = nf;
        }
    }
    else
    {
        stInfo = collectSimpleTypeInfo(T);
    }
    Type2TypeInfo.emplace(T, stInfo);
    symInfo->addStInfo(stInfo);
    return stInfo;
}

◆ createSVFDataStructure()

void LLVMModuleSet::createSVFDataStructure ( )

private

Function

then traverse candidate sets

GlobalVariable

GlobalAlias

GlobalIFunc

Definition at line 202 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)
    {
        createSVFFunction(func);
    }
    for (const Function* func: candidateDecls)
    {
        createSVFFunction(func);
    }
 
    // Store annotations of functions in extapi.bc
    for (const auto& pair : ExtFun2Annotations)
    {
        const SVFFunction* svffun = getSVFFunction(pair.first);
        ExtAPI::getExtAPI()->setExtFuncAnnotations(svffun, pair.second);
    }
 
    for (const Module& mod : modules)
    {
        for (const GlobalVariable& global :  mod.globals())
        {
            SVFGlobalValue* svfglobal = new SVFGlobalValue(
                global.getName().str(), getSVFType(global.getType()));
            svfModule->addGlobalSet(svfglobal);
            addGlobalValueMap(&global, svfglobal);
        }
 
        for (const GlobalAlias& alias : mod.aliases())
        {
            SVFGlobalValue* svfalias = new SVFGlobalValue(
                alias.getName().str(), getSVFType(alias.getType()));
            svfModule->addAliasSet(svfalias);
            addGlobalValueMap(&alias, svfalias);
        }
 
        for (const GlobalIFunc& ifunc : mod.ifuncs())
        {
            SVFGlobalValue* svfifunc = new SVFGlobalValue(
                ifunc.getName().str(), getSVFType(ifunc.getType()));
            svfModule->addAliasSet(svfifunc);
            addGlobalValueMap(&ifunc, svfifunc);
        }
    }
}

◆ createSVFFunction()

void LLVMModuleSet::createSVFFunction ( const Function * func )

private

Definition at line 275 of file LLVMModule.cpp.

{
    SVFFunction* svfFunc = new SVFFunction(
        getSVFType(func->getType()),
        SVFUtil::cast<SVFFunctionType>(
            getSVFType(func->getFunctionType())),
        func->isDeclaration(), LLVMUtil::isIntrinsicFun(func),
        func->hasAddressTaken(), func->isVarArg(), new SVFLoopAndDomInfo);
    svfModule->addFunctionSet(svfFunc);
    addFunctionMap(func, svfFunc);
 
    for (const Argument& arg : func->args())
    {
        SVFArgument* svfarg = new SVFArgument(
            getSVFType(arg.getType()), svfFunc, arg.getArgNo(),
            LLVMUtil::isArgOfUncalledFunction(&arg));
        // Setting up arg name
        if (!arg.hasName())
            svfarg->setName(std::to_string(arg.getArgNo()));
 
        svfFunc->addArgument(svfarg);
        addArgumentMap(&arg, svfarg);
    }
 
    for (const BasicBlock& bb : *func)
    {
        SVFBasicBlock* svfBB =
            new SVFBasicBlock(getSVFType(bb.getType()), svfFunc);
        svfFunc->addBasicBlock(svfBB);
        addBasicBlockMap(&bb, svfBB);
        for (const Instruction& inst : bb)
        {
            SVFInstruction* svfInst = nullptr;
            if (const CallBase* call = SVFUtil::dyn_cast<CallBase>(&inst))
            {
                svfInst = new SVFCallInst(
                    getSVFType(call->getType()), svfBB,
                    call->getFunctionType()->isVarArg(),
                    inst.isTerminator());
            }
            else
            {
                svfInst =
                    new SVFInstruction(getSVFType(inst.getType()),
                                       svfBB, inst.isTerminator(),
                                       SVFUtil::isa<ReturnInst>(inst));
            }
 
            addInstructionMap(&inst, svfInst);
        }
    }
}

◆ dumpModulesToFile()

void LLVMModuleSet::dumpModulesToFile ( const std::string & suffix )

Definition at line 1198 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);
 
#if (LLVM_VERSION_MAJOR >= 7)
        WriteBitcodeToFile(mod, OS);
#else
        WriteBitcodeToFile(&mod, OS);
#endif
 
        OS.flush();
    }
}

◆ empty()

bool SVF::LLVMModuleSet::empty ( ) const

inline

Definition at line 385 of file LLVMModule.h.

    {
        return getModuleNum() == 0;
    }

◆ getCallBlock()

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

inlineprivate

Get/Add a call node.

Definition at line 438 of file LLVMModule.h.

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

◆ getCallGraphNode()

CallGraphNode * SVF::LLVMModuleSet::getCallGraphNode ( const Function * fun ) const

inline

Definition at line 253 of file LLVMModule.h.

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

◆ getCallICFGNode()

CallICFGNode * LLVMModuleSet::getCallICFGNode ( const Instruction * cs )

get a call node

Definition at line 1443 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 379 of file LLVMModule.h.

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

◆ getDomTree()

DominatorTree & LLVMModuleSet::getDomTree ( const Function * fun )

Definition at line 102 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;
}

◆ getFunEntryBlock()

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

inlineprivate

Get/Add a function entry node.

Definition at line 464 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 335 of file LLVMModule.h.

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

◆ getFunExitBlock()

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

inlineprivate

Get/Add a function exit node.

Definition at line 473 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 342 of file LLVMModule.h.

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

◆ getGlobalRep()

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

inline

Definition at line 357 of file LLVMModule.h.

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

◆ getICFG()

ICFG * SVF::LLVMModuleSet::getICFG ( )

inline

Definition at line 397 of file LLVMModule.h.

    {
        return icfg;
    }

◆ getICFGNode()

ICFGNode * LLVMModuleSet::getICFGNode ( const Instruction * inst )

Get a basic block ICFGNode.

Definition at line 1416 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 455 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 1461 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 635 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(priority
                                                  ->getZExtValue(),
                                                  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 153 of file LLVMModule.h.

    {
        return modules;
    }

◆ getLLVMModuleSet()

static LLVMModuleSet * SVF::LLVMModuleSet::getLLVMModuleSet ( )

inlinestatic

Definition at line 122 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 1387 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() [1/2]

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

inline

Definition at line 246 of file LLVMModule.h.

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

◆ getLLVMValue() [2/2]

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

inline

Definition at line 239 of file LLVMModule.h.

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

◆ getMainLLVMModule()

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

inline

Definition at line 364 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 158 of file LLVMModule.h.

    {
        return &getModuleRef(idx);
    }

◆ getModuleNum()

u32_t SVF::LLVMModuleSet::getModuleNum ( ) const

inline

Definition at line 148 of file LLVMModule.h.

    {
        return modules.size();
    }

◆ getModuleRef()

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

inline

Definition at line 163 of file LLVMModule.h.

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

◆ getOtherSVFConstant()

SVFConstant * LLVMModuleSet::getOtherSVFConstant ( const Constant * oc )

Definition at line 1329 of file LLVMModule.cpp.

{
    LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(oc);
    if(it!=LLVMConst2SVFConst.end())
    {
        return it->second;
    }
    else
    {
        SVFConstant* svfoc = new SVFConstant(getSVFType(oc->getType()));
        svfModule->addConstant(svfoc);
        addOtherConstantMap(oc,svfoc);
        return svfoc;
    }
}

◆ getRetBlock()

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

inlineprivate

Get/Add a return node.

Definition at line 447 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 1452 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;
}

◆ getSVFArgument()

SVFArgument * SVF::LLVMModuleSet::getSVFArgument ( const Argument * arg ) const

inline

Definition at line 281 of file LLVMModule.h.

    {
        LLVMArgument2SVFArgumentMap::const_iterator it = LLVMArgument2SVFArgument.find(arg);
        assert(it!=LLVMArgument2SVFArgument.end() && "SVF Argument not found!");
        return it->second;
    }

◆ getSVFBasicBlock()

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

inline

Definition at line 267 of file LLVMModule.h.

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

◆ getSVFConstantData()

SVFConstantData * LLVMModuleSet::getSVFConstantData ( const ConstantData * cd )

bitwidth == 1 : cint has value from getZExtValue() because bool true will be translated to -1 using sign extension (i.e., getSExtValue). bitwidth <=64 1 : cint has value from getSExtValue() bitwidth >64 1 : cint has value 0 because it represents an invalid int

Definition at line 1264 of file LLVMModule.cpp.

{
    LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(cd);
    if(it!=LLVMConst2SVFConst.end())
    {
        assert(SVFUtil::isa<SVFConstantData>(it->second) && "not a SVFConstantData type!");
        return SVFUtil::cast<SVFConstantData>(it->second);
    }
    else
    {
        SVFConstantData* svfcd = nullptr;
        if(const ConstantInt* cint = SVFUtil::dyn_cast<ConstantInt>(cd))
        {
            if(cint->getBitWidth() == 1)
                svfcd = new SVFConstantInt(getSVFType(cint->getType()), cint->getZExtValue(), cint->getZExtValue());
            else if(cint->getBitWidth() <= 64 && cint->getBitWidth() > 1)
                svfcd = new SVFConstantInt(getSVFType(cint->getType()), cint->getZExtValue(), cint->getSExtValue());
            else
                svfcd = new SVFConstantInt(getSVFType(cint->getType()), 0, 0);
        }
        else if(const ConstantFP* cfp = SVFUtil::dyn_cast<ConstantFP>(cd))
        {
            double dval = 0;
            // TODO: Why only double is considered? What about float?
            if (cfp->isNormalFP())
            {
                const llvm::fltSemantics& semantics = cfp->getValueAPF().getSemantics();
                if (&semantics == &llvm::APFloat::IEEEhalf() ||
                        &semantics == &llvm::APFloat::IEEEsingle() ||
                        &semantics == &llvm::APFloat::IEEEdouble() ||
                        &semantics == &llvm::APFloat::IEEEquad() ||
                        &semantics == &llvm::APFloat::x87DoubleExtended())
                {
                    dval = cfp->getValueAPF().convertToDouble();
                }
                else
                {
                    assert (false && "Unsupported floating point type");
                    abort();
                }
            }
            else
            {
                // other cfp type, like isZero(), isInfinity(), isNegative(), etc.
                // do nothing
            }
            svfcd = new SVFConstantFP(getSVFType(cd->getType()), dval);
        }
        else if(SVFUtil::isa<ConstantPointerNull>(cd))
            svfcd = new SVFConstantNullPtr(getSVFType(cd->getType()));
        else if (SVFUtil::isa<UndefValue>(cd))
            svfcd = new SVFBlackHoleValue(getSVFType(cd->getType()));
        else
            svfcd = new SVFConstantData(getSVFType(cd->getType()));
 
 
        svfModule->addConstant(svfcd);
        addConstantDataMap(cd,svfcd);
        return svfcd;
    }
}

◆ getSVFFunction() [1/2]

SVFFunction * SVF::LLVMModuleSet::getSVFFunction ( const Function * fun ) const

inline

Definition at line 260 of file LLVMModule.h.

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

◆ getSVFFunction() [2/2]

const SVFFunction * SVF::LLVMModuleSet::getSVFFunction ( const std::string & name )

inline

Get the corresponding Function based on its name.

Definition at line 307 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 llvmModuleSet->getSVFFunction(fun);
            }
        }
        return nullptr;
    }

◆ getSVFGlobalValue()

SVFGlobalValue * SVF::LLVMModuleSet::getSVFGlobalValue ( const GlobalValue * g ) const

inline

Definition at line 288 of file LLVMModule.h.

    {
        if (auto glob_var = llvm::dyn_cast<llvm::GlobalVariable>(g);
                hasGlobalRep(glob_var))
        {
            g = getGlobalRep(glob_var);
        }
        LLVMConst2SVFConstMap::const_iterator it = LLVMConst2SVFConst.find(g);
        assert(it!=LLVMConst2SVFConst.end() && "SVF Global not found!");
        assert(SVFUtil::isa<SVFGlobalValue>(it->second) && "not a SVFGlobal type!");
        return SVFUtil::cast<SVFGlobalValue>(it->second);
    }

◆ getSVFInstruction()

SVFInstruction * SVF::LLVMModuleSet::getSVFInstruction ( const Instruction * inst ) const

inline

Definition at line 274 of file LLVMModule.h.

    {
        LLVMInst2SVFInstMap::const_iterator it = LLVMInst2SVFInst.find(inst);
        assert(it!=LLVMInst2SVFInst.end() && "SVF Instruction not found!");
        return it->second;
    }

◆ getSVFModule()

SVFModule * SVF::LLVMModuleSet::getSVFModule ( )

inline

Definition at line 141 of file LLVMModule.h.

    {
        return svfModule;
    }

◆ getSVFOtherValue()

SVFOtherValue * LLVMModuleSet::getSVFOtherValue ( const Value * ov )

Definition at line 1345 of file LLVMModule.cpp.

{
    LLVMValue2SVFOtherValueMap::const_iterator it = LLVMValue2SVFOtherValue.find(ov);
    if(it!=LLVMValue2SVFOtherValue.end())
    {
        return it->second;
    }
    else
    {
        SVFOtherValue* svfov =
            SVFUtil::isa<MetadataAsValue>(ov)
            ? new SVFMetadataAsValue(getSVFType(ov->getType()))
            : new SVFOtherValue(getSVFType(ov->getType()));
        svfModule->addOtherValue(svfov);
        addOtherValueMap(ov,svfov);
        return svfov;
    }
}

◆ getSVFType()

SVFType * LLVMModuleSet::getSVFType ( const Type * T )

Get or create SVFType and typeinfo.

Get or create SVFType and typeinfo

Definition at line 1401 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;
}

◆ getSVFValue()

SVFValue * LLVMModuleSet::getSVFValue ( const Value * value )

Definition at line 1364 of file LLVMModule.cpp.

{
    if (const Function* fun = SVFUtil::dyn_cast<Function>(value))
        return getSVFFunction(fun);
    else if (const BasicBlock* bb = SVFUtil::dyn_cast<BasicBlock>(value))
        return getSVFBasicBlock(bb);
    else if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(value))
        return getSVFInstruction(inst);
    else if (const Argument* arg = SVFUtil::dyn_cast<Argument>(value))
        return getSVFArgument(arg);
    else if (const Constant* cons = SVFUtil::dyn_cast<Constant>(value))
    {
        if (const ConstantData* cd = SVFUtil::dyn_cast<ConstantData>(cons))
            return getSVFConstantData(cd);
        else if (const GlobalValue* glob = SVFUtil::dyn_cast<GlobalValue>(cons))
            return getSVFGlobalValue(glob);
        else
            return getOtherSVFConstant(cons);
    }
    else
        return getSVFOtherValue(value);
}

◆ getTypeInference()

ObjTypeInference * LLVMModuleSet::getTypeInference ( )

Definition at line 97 of file LLVMModule.cpp.

{
    return typeInference;
}

◆ hasGlobalRep()

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

inline

Global to rep.

Definition at line 351 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 1430 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;
}

◆ initDomTree()

void LLVMModuleSet::initDomTree	(	SVFFunction *	func,
		const Function *	f
	)

private

Definition at line 414 of file LLVMModule.cpp.

{
    if (fun->isDeclaration())
        return;
    //process and stored dt & df
    DominanceFrontier df;
    DominatorTree& dt = getDomTree(fun);
    df.analyze(dt);
    LoopInfo loopInfo = LoopInfo(dt);
    PostDominatorTree pdt = PostDominatorTree(const_cast<Function&>(*fun));
    SVFLoopAndDomInfo* ld = svffun->getLoopAndDomInfo();
 
    Map<const SVFBasicBlock*,Set<const SVFBasicBlock*>> & dfBBsMap = ld->getDomFrontierMap();
    for (DominanceFrontierBase::const_iterator dfIter = df.begin(), eDfIter = df.end(); dfIter != eDfIter; dfIter++)
    {
        const BasicBlock* keyBB = dfIter->first;
        const std::set<BasicBlock* >& domSet = dfIter->second;
        Set<const SVFBasicBlock*>& valueBasicBlocks = dfBBsMap[getSVFBasicBlock(keyBB)];
        for (const BasicBlock* bbValue:domSet)
        {
            valueBasicBlocks.insert(getSVFBasicBlock(bbValue));
        }
    }
    std::vector<const SVFBasicBlock*> reachableBBs;
    LLVMUtil::getFunReachableBBs(fun, reachableBBs);
    ld->setReachableBBs(reachableBBs);
 
    for (Function::const_iterator bit = fun->begin(), beit = fun->end(); bit!=beit; ++bit)
    {
        const BasicBlock &bb = *bit;
        SVFBasicBlock* svfBB = getSVFBasicBlock(&bb);
        if (DomTreeNode* dtNode = dt.getNode(&bb))
        {
            SVFLoopAndDomInfo::BBSet& bbSet = ld->getDomTreeMap()[svfBB];
            for (const auto domBB : *dtNode)
            {
                const auto* domSVFBB = getSVFBasicBlock(domBB->getBlock());
                bbSet.insert(domSVFBB);
            }
        }
 
        if (DomTreeNode* pdtNode = pdt.getNode(&bb))
        {
            u32_t level = pdtNode->getLevel();
            ld->getBBPDomLevel()[svfBB] = level;
            BasicBlock* idomBB = pdtNode->getIDom()->getBlock();
            const SVFBasicBlock* idom = idomBB == NULL ? NULL: getSVFBasicBlock(idomBB);
            ld->getBB2PIdom()[svfBB] = idom;
 
            SVFLoopAndDomInfo::BBSet& bbSet = ld->getPostDomTreeMap()[svfBB];
            for (const auto domBB : *pdtNode)
            {
                const auto* domSVFBB = getSVFBasicBlock(domBB->getBlock());
                bbSet.insert(domSVFBB);
            }
        }
 
        if (const Loop* loop = loopInfo.getLoopFor(&bb))
        {
            for (const BasicBlock* loopBlock : loop->getBlocks())
            {
                const SVFBasicBlock* loopbb = getSVFBasicBlock(loopBlock);
                ld->addToBB2LoopMap(svfBB, loopbb);
            }
        }
    }
}

◆ initSVFBasicBlock()

void LLVMModuleSet::initSVFBasicBlock ( const Function * func )

private

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

Definition at line 346 of file LLVMModule.cpp.

{
    SVFFunction *svfFun = getSVFFunction(func);
    for (Function::const_iterator bit = func->begin(), ebit = func->end(); bit != ebit; ++bit)
    {
        const BasicBlock* bb = &*bit;
        SVFBasicBlock* svfbb = getSVFBasicBlock(bb);
        for (succ_const_iterator succ_it = succ_begin(bb); succ_it != succ_end(bb); succ_it++)
        {
            const SVFBasicBlock* svf_scc_bb = getSVFBasicBlock(*succ_it);
            svfbb->addSuccBasicBlock(svf_scc_bb);
        }
        for (const_pred_iterator pred_it = pred_begin(bb); pred_it != pred_end(bb); pred_it++)
        {
            const SVFBasicBlock* svf_pred_bb = getSVFBasicBlock(*pred_it);
            svfbb->addPredBasicBlock(svf_pred_bb);
        }
 
        if (svfbb->getSuccessors().empty())
        {
            if (LLVMUtil::basicBlockHasRetInst(bb))
            {
                assert((LLVMUtil::functionDoesNotRet(func) ||
                        SVFUtil::isa<ReturnInst>(bb->back())) &&
                       "last inst must be return inst");
                svfFun->setExitBlock(svfbb);
            }
        }
 
        for (BasicBlock::const_iterator iit = bb->begin(), eiit = bb->end(); iit != eiit; ++iit)
        {
            const Instruction* inst = &*iit;
            if(const CallBase* call = SVFUtil::dyn_cast<CallBase>(inst))
            {
                SVFInstruction* svfinst = getSVFInstruction(call);
                SVFCallInst* svfcall = SVFUtil::cast<SVFCallInst>(svfinst);
                auto called_llvmval = call->getCalledOperand()->stripPointerCasts();
                if (const Function* called_llvmfunc = SVFUtil::dyn_cast<Function>(called_llvmval))
                {
                    SVFFunction* callee = getSVFFunction(called_llvmfunc);
                    svfcall->setCalledOperand(callee);
                }
                else
                {
                    svfcall->setCalledOperand(getSVFValue(called_llvmval));
                }
                for(u32_t i = 0; i < call->arg_size(); i++)
                {
                    SVFValue* svfval = getSVFValue(call->getArgOperand(i));
                    svfcall->addArgument(svfval);
                }
            }
        }
    }
    // 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 (svfFun->exitBlock == nullptr && svfFun->hasBasicBlock())
    {
        SVFBasicBlock* retBB = const_cast<SVFBasicBlock*>(svfFun->back());
        assert((LLVMUtil::functionDoesNotRet(func) ||
                SVFUtil::isa<ReturnInst>(&func->back().back())) &&
               "last inst must be return inst");
        svfFun->setExitBlock(retBB);
    }
}

◆ initSVFFunction()

void LLVMModuleSet::initSVFFunction ( )

private

Function

Definition at line 328 of file LLVMModule.cpp.

{
    for (Module& mod : modules)
    {
        for (const Function& f : mod.functions())
        {
            SVFFunction* svffun = getSVFFunction(&f);
            initSVFBasicBlock(&f);
 
            if (!SVFUtil::isExtCall(svffun))
            {
                initDomTree(svffun, &f);
            }
        }
    }
}

◆ loadExtAPIModules()

void LLVMModuleSet::loadExtAPIModules ( )

private

Definition at line 596 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 531 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
        SVFModule::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));
    }
}

◆ prePassSchedule()

void LLVMModuleSet::prePassSchedule ( )

private

Invoke llvm passes to modify module.

Invoke llvm passes to modify module

BreakConstantGEPs Pass

MergeFunctionRets Pass

Definition at line 486 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;
            p2->runOnFunction(fun);
        }
    }
}

◆ preProcessBCs()

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

static

Definition at line 510 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()

static void SVF::LLVMModuleSet::releaseLLVMModuleSet ( )

inlinestatic

Definition at line 129 of file LLVMModule.h.

    {
        delete llvmModuleSet;
        llvmModuleSet = nullptr;
    }

◆ setValueAttr()

void LLVMModuleSet::setValueAttr	(	const Value *	val,
		SVFValue *	value
	)

private

Definition at line 1229 of file LLVMModule.cpp.

{
    SVFValue2LLVMValue[svfvalue] = val;
 
    if(val->hasName())
        svfvalue->setName(val->getName().str());
    if (LLVMUtil::isPtrInUncalledFunction(val))
        svfvalue->setPtrInUncalledFunction();
    if (LLVMUtil::isConstDataOrAggData(val))
        svfvalue->setConstDataOrAggData();
 
    if (SVFGlobalValue* glob = SVFUtil::dyn_cast<SVFGlobalValue>(svfvalue))
    {
        const Value* llvmVal = LLVMUtil::getGlobalRep(val);
        assert(SVFUtil::isa<GlobalValue>(llvmVal) && "not a GlobalValue?");
        glob->setDefGlobalForMultipleModule(getSVFGlobalValue(SVFUtil::cast<GlobalValue>(llvmVal)));
    }
    if (SVFFunction* svffun = SVFUtil::dyn_cast<SVFFunction>(svfvalue))
    {
        const Function* func = SVFUtil::cast<Function>(val);
        svffun->setIsNotRet(LLVMUtil::functionDoesNotRet(func));
        svffun->setIsUncalledFunction(LLVMUtil::isUncalledFunction(func));
        svffun->setDefFunForMultipleModule(getSVFFunction(func));
    }
 
    svfvalue->setSourceLoc(LLVMUtil::getSourceLoc(val));
}

Friends And Related Symbol Documentation

◆ ICFGBuilder

friend class ICFGBuilder

friend

Definition at line 47 of file LLVMModule.h.

◆ SVFIRBuilder

friend class SVFIRBuilder

friend

Definition at line 46 of file LLVMModule.h.

Member Data Documentation

◆ callgraph

CallGraph* SVF::LLVMModuleSet::callgraph

private

Definition at line 110 of file LLVMModule.h.

◆ CSToCallNodeMap

CSToCallNodeMapTy SVF::LLVMModuleSet::CSToCallNodeMap

private

map a callsite to its CallICFGNode

Definition at line 105 of file LLVMModule.h.

◆ CSToRetNodeMap

CSToRetNodeMapTy SVF::LLVMModuleSet::CSToRetNodeMap

private

map a callsite to its RetICFGNode

Definition at line 106 of file LLVMModule.h.

◆ ExtFun2Annotations

Fun2AnnoMap SVF::LLVMModuleSet::ExtFun2Annotations

private

Record annotations of function in extapi.bc.

Definition at line 88 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 86 of file LLVMModule.h.

◆ FunToDominatorTree

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

private

Definition at line 112 of file LLVMModule.h.

◆ FunToFunEntryNodeMap

FunToFunEntryNodeMapTy SVF::LLVMModuleSet::FunToFunEntryNodeMap

private

map a function to its FunExitICFGNode

Definition at line 108 of file LLVMModule.h.

◆ FunToFunExitNodeMap

FunToFunExitNodeMapTy SVF::LLVMModuleSet::FunToFunExitNodeMap

private

map a function to its FunEntryICFGNode

Definition at line 109 of file LLVMModule.h.

◆ GlobalDefToRepMap

GlobalDefToRepMapTy SVF::LLVMModuleSet::GlobalDefToRepMap

private

Global definition to a rep definition map.

Definition at line 90 of file LLVMModule.h.

◆ icfg

ICFG* SVF::LLVMModuleSet::icfg

private

Definition at line 80 of file LLVMModule.h.

◆ InstToBlockNodeMap

InstToBlockNodeMapTy SVF::LLVMModuleSet::InstToBlockNodeMap

private

map a basic block to its ICFGNode

Definition at line 107 of file LLVMModule.h.

◆ LLVMArgument2SVFArgument

LLVMArgument2SVFArgumentMap SVF::LLVMModuleSet::LLVMArgument2SVFArgument

private

Definition at line 96 of file LLVMModule.h.

◆ LLVMBB2SVFBB

LLVMBB2SVFBBMap SVF::LLVMModuleSet::LLVMBB2SVFBB

private

Definition at line 94 of file LLVMModule.h.

◆ LLVMConst2SVFConst

LLVMConst2SVFConstMap SVF::LLVMModuleSet::LLVMConst2SVFConst

private

Definition at line 97 of file LLVMModule.h.

◆ LLVMFunc2CallGraphNode

LLVMFun2CallGraphNodeMap SVF::LLVMModuleSet::LLVMFunc2CallGraphNode

private

Map an LLVM Function to an CallGraph Node.

Definition at line 93 of file LLVMModule.h.

◆ LLVMFunc2SVFFunc

LLVMFun2SVFFunMap SVF::LLVMModuleSet::LLVMFunc2SVFFunc

private

Map an LLVM Function to an SVF Function.

Definition at line 92 of file LLVMModule.h.

◆ LLVMInst2SVFInst

LLVMInst2SVFInstMap SVF::LLVMModuleSet::LLVMInst2SVFInst

private

Definition at line 95 of file LLVMModule.h.

◆ llvmModuleSet

LLVMModuleSet * LLVMModuleSet::llvmModuleSet = nullptr

staticprivate

Definition at line 76 of file LLVMModule.h.

◆ LLVMType2SVFType

LLVMType2SVFTypeMap SVF::LLVMModuleSet::LLVMType2SVFType

private

Definition at line 100 of file LLVMModule.h.

◆ LLVMValue2SVFOtherValue

LLVMValue2SVFOtherValueMap SVF::LLVMModuleSet::LLVMValue2SVFOtherValue

private

Definition at line 98 of file LLVMModule.h.

◆ modules

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

private

Definition at line 83 of file LLVMModule.h.

◆ owned_ctx

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

private

Definition at line 81 of file LLVMModule.h.

◆ owned_modules

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

private

Definition at line 82 of file LLVMModule.h.

◆ preProcessed

bool LLVMModuleSet::preProcessed = false

staticprivate

Definition at line 77 of file LLVMModule.h.

◆ SVFBaseNode2LLVMValue

SVFBaseNode2LLVMValueMap SVF::LLVMModuleSet::SVFBaseNode2LLVMValue

private

Definition at line 104 of file LLVMModule.h.

◆ svfModule

SVFModule* SVF::LLVMModuleSet::svfModule

private

Borrowed from singleton SVFModule::svfModule.

Definition at line 79 of file LLVMModule.h.

◆ SVFValue2LLVMValue

SVFValue2LLVMValueMap SVF::LLVMModuleSet::SVFValue2LLVMValue

private

Definition at line 99 of file LLVMModule.h.

◆ symInfo

SymbolTableInfo* SVF::LLVMModuleSet::symInfo

private

Definition at line 78 of file LLVMModule.h.

◆ Type2TypeInfo

Type2TypeInfoMap SVF::LLVMModuleSet::Type2TypeInfo

private

Definition at line 101 of file LLVMModule.h.

◆ typeInference

ObjTypeInference* SVF::LLVMModuleSet::typeInference

private

Definition at line 102 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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ CSToCallNodeMapTy

◆ CSToRetNodeMapTy

◆ Fun2AnnoMap

◆ FunctionSetType

◆ FunDeclToDefMapTy

◆ FunDefToDeclsMapTy

◆ FunToFunEntryNodeMapTy

◆ FunToFunExitNodeMapTy

◆ GlobalDefToRepMapTy

◆ InstToBlockNodeMapTy

◆ LLVMArgument2SVFArgumentMap

◆ LLVMBB2SVFBBMap

◆ LLVMConst2SVFConstMap

◆ LLVMFun2CallGraphNodeMap

◆ LLVMFun2SVFFunMap

◆ LLVMInst2SVFInstMap

◆ LLVMType2SVFTypeMap

◆ LLVMValue2SVFOtherValueMap

◆ SVFBaseNode2LLVMValueMap

◆ SVFValue2LLVMValueMap

◆ Type2TypeInfoMap

Constructor & Destructor Documentation

◆ LLVMModuleSet()

◆ ~LLVMModuleSet()

Member Function Documentation

◆ addArgumentMap()

◆ addBasicBlockMap()

◆ addConstantDataMap()

◆ addFunctionMap() [1/2]

◆ addFunctionMap() [2/2]

◆ addGlobalValueMap()

◆ addInstructionMap() [1/4]

◆ addInstructionMap() [2/4]

◆ addInstructionMap() [3/4]

◆ addInstructionMap() [4/4]

◆ addOtherConstantMap()

◆ addOtherValueMap()

◆ addSVFMain()

◆ addSVFTypeInfo()

◆ addToLLVMVal2SVFVarMap()

◆ build()

◆ buildFunToFunMap()

◆ buildGlobalDefToRepMap()

◆ buildSVFModule() [1/2]

◆ buildSVFModule() [2/2]

◆ buildSymbolTable()

◆ collectArrayInfo()

◆ collectExtFunAnnotations()

◆ collectSimpleTypeInfo()

◆ collectStructInfo()

◆ collectTypeInfo()

◆ createSVFDataStructure()

◆ createSVFFunction()

◆ dumpModulesToFile()

◆ empty()

◆ getCallBlock()

◆ getCallGraphNode()

◆ getCallICFGNode()

◆ getContext()

◆ getDomTree()

◆ getFunEntryBlock()

◆ getFunEntryICFGNode()

◆ getFunExitBlock()

◆ getFunExitICFGNode()

◆ getGlobalRep()

◆ getICFG()

◆ getICFGNode()

◆ getIntraBlock()

◆ getIntraICFGNode()

◆ getLLVMGlobalFunctions()

◆ getLLVMModules()