svf-lib 1.0.1301 → 1.0.1302

package/SVF-linux/include/SVF-FE/LLVMModule.h

@@ -1,319 +0,0 @@
-//===- LLVMModule.h -- LLVM Module class-----------------------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * LLVMModule.h
- *
- *  Created on: 23 Mar.2020
- *      Author: Yulei Sui
- */
-
-#ifndef INCLUDE_SVF_FE_LLVMMODULE_H_
-#define INCLUDE_SVF_FE_LLVMMODULE_H_
-
-#include "SVF-FE/BasicTypes.h"
-#include "SVF-FE/CPPUtil.h"
-#include "Util/BasicTypes.h"
-#include "Util/SVFModule.h"
-
-namespace SVF
-{
-
-class LLVMModuleSet
-{
-public:
-
-    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 BasicBlock*, SVFBasicBlock*> LLVMBB2SVFBBMap;
-    typedef Map<const Instruction*, SVFInstruction*> LLVMInst2SVFInstMap;
-    typedef Map<const GlobalValue*, SVFGlobalValue*> LLVMGlobal2SVFGlobalMap;
-    typedef Map<const Argument*, SVFArgument*> LLVMArgument2SVFArgumentMap;
-    typedef Map<const ConstantData*, SVFConstantData*> LLVMConstData2SVFConstDataMap;
-    typedef Map<const Value*, SVFOtherValue*> LLVMValue2SVFOtherValueMap;
-
-private:
-    static LLVMModuleSet* llvmModuleSet;
-    SVFModule* svfModule;
-    std::unique_ptr<LLVMContext> cxts;
-    std::vector<std::unique_ptr<Module>> owned_modules;
-    std::vector<std::reference_wrapper<Module>> modules;
-
-    /// Function declaration to function definition map
-    FunDeclToDefMapTy FunDeclToDefMap;
-    /// Function definition to function declaration map
-    FunDefToDeclsMapTy FunDefToDeclsMap;
-    /// Global definition to a rep definition map
-    GlobalDefToRepMapTy GlobalDefToRepMap;
-
-    LLVMFun2SVFFunMap LLVMFunc2SVFFunc; ///< Map an LLVM Function to an SVF Function
-    LLVMBB2SVFBBMap LLVMBB2SVFBB;
-    LLVMInst2SVFInstMap LLVMInst2SVFInst;
-    LLVMArgument2SVFArgumentMap LLVMArgument2SVFArgument;
-    LLVMGlobal2SVFGlobalMap LLVMGlobal2SVFGlobal;
-    LLVMConstData2SVFConstDataMap LLVMConstData2SVFConstData;
-    LLVMValue2SVFOtherValueMap LLVMValue2SVFOtherValue;
-
-    /// Constructor
-    LLVMModuleSet(): svfModule(nullptr), cxts(nullptr), preProcessed(false) {}
-
-    void build();
-
-public:
-    static inline LLVMModuleSet* getLLVMModuleSet()
-    {
-        if (llvmModuleSet == nullptr)
-            llvmModuleSet = new LLVMModuleSet();
-        return llvmModuleSet;
-    }
-
-    static void releaseLLVMModuleSet()
-    {
-        if (llvmModuleSet)
-            delete llvmModuleSet;
-        llvmModuleSet = nullptr;
-    }
-
-    SVFModule* buildSVFModule(Module& mod);
-    SVFModule* buildSVFModule(const std::vector<std::string>& moduleNameVec);
-
-    inline SVFModule* getSVFModule()
-    {
-        assert(svfModule && "svfModule has not been built yet!");
-        return svfModule;
-    }
-
-    void preProcessBCs(std::vector<std::string>& moduleNameVec);
-
-    u32_t getModuleNum() const
-    {
-        return modules.size();
-    }
-
-    const std::vector<std::reference_wrapper<Module>>& getLLVMModules() const
-    {
-        return modules;
-    }
-
-    Module *getModule(u32_t idx) const
-    {
-        return &getModuleRef(idx);
-    }
-
-    Module &getModuleRef(u32_t idx) const
-    {
-        assert(idx < getModuleNum() && "Out of range.");
-        return modules[idx];
-    }
-
-    // Dump modules to files
-    void dumpModulesToFile(const std::string suffix);
-
-    inline void addFunctionMap(const Function* func, SVFFunction* svfFunc)
-    {
-        LLVMFunc2SVFFunc[func] = svfFunc;
-        setValueAttr(func,svfFunc);
-    }
-    inline void addBasicBlockMap(const BasicBlock* bb, SVFBasicBlock* svfBB)
-    {
-        LLVMBB2SVFBB[bb] = svfBB;
-        setValueAttr(bb,svfBB);
-    }
-    inline void addInstructionMap(const Instruction* inst, SVFInstruction* svfInst)
-    {
-        LLVMInst2SVFInst[inst] = svfInst;
-        setValueAttr(inst,svfInst);
-    }
-    inline void addArgumentMap(const Argument* arg, SVFArgument* svfArg)
-    {
-        LLVMArgument2SVFArgument[arg] = svfArg;
-        setValueAttr(arg,svfArg);
-    }
-    inline void addGlobalValueMap(const GlobalValue* glob, SVFGlobalValue* svfglob)
-    {
-        LLVMGlobal2SVFGlobal[glob] = svfglob;
-        setValueAttr(glob,svfglob);
-    }
-    inline void addConstantDataMap(const ConstantData* cd, SVFConstantData* svfcd)
-    {
-        LLVMConstData2SVFConstData[cd] = svfcd;
-        setValueAttr(cd,svfcd);
-    }
-    inline void addOtherValueMap(const Value* ov, SVFOtherValue* svfov)
-    {
-        LLVMValue2SVFOtherValue[ov] = svfov;
-        setValueAttr(ov,svfov);
-    }
-
-    SVFValue* getSVFValue(const Value* value);
-
-    inline SVFFunction* getSVFFunction(const Function* fun) const
-    {
-        LLVMFun2SVFFunMap::const_iterator it = LLVMFunc2SVFFunc.find(fun);
-        assert(it!=LLVMFunc2SVFFunc.end() && "SVF Function not found!");
-        return it->second;
-    }
-
-    inline SVFBasicBlock* getSVFBasicBlock(const BasicBlock* bb) const
-    {
-        LLVMBB2SVFBBMap::const_iterator it = LLVMBB2SVFBB.find(bb);
-        assert(it!=LLVMBB2SVFBB.end() && "SVF BasicBlock not found!");
-        return it->second;
-    }
-
-    inline SVFInstruction* getSVFInstruction(const Instruction* inst) const
-    {
-        LLVMInst2SVFInstMap::const_iterator it = LLVMInst2SVFInst.find(inst);
-        assert(it!=LLVMInst2SVFInst.end() && "SVF Instruction not found!");
-        return it->second;
-    }
-
-    inline SVFArgument* getSVFArgument(const Argument* arg) const
-    {
-        LLVMArgument2SVFArgumentMap::const_iterator it = LLVMArgument2SVFArgument.find(arg);
-        assert(it!=LLVMArgument2SVFArgument.end() && "SVF Argument not found!");
-        return it->second;
-    }
-
-    inline SVFGlobalValue* getSVFGlobalValue(const GlobalValue* g) const
-    {
-        LLVMGlobal2SVFGlobalMap::const_iterator it = LLVMGlobal2SVFGlobal.find(g);
-        assert(it!=LLVMGlobal2SVFGlobal.end() && "SVF Global not found!");
-        return it->second;
-    }
-
-    SVFConstantData* getSVFConstantData(const ConstantData* cd);
-
-    SVFOtherValue* getSVFOtherValue(const Value* ov);
-
-    /// Get the corresponding Function based on its name
-    inline const SVFFunction* getSVFFunction(std::string name)
-    {
-        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;
-    }
-
-    bool hasDefinition(const Function* fun) const
-    {
-        assert(fun->isDeclaration() && "not a function declaration?");
-        FunDeclToDefMapTy::const_iterator it = FunDeclToDefMap.find(fun);
-        return it != FunDeclToDefMap.end();
-    }
-
-    const Function* getDefinition(const Function* fun) const
-    {
-        assert(fun->isDeclaration() && "not a function declaration?");
-        FunDeclToDefMapTy::const_iterator it = FunDeclToDefMap.find(fun);
-        assert(it != FunDeclToDefMap.end() && "has no definition?");
-        return it->second;
-    }
-
-    bool hasDeclaration(const Function* fun) const
-    {
-        if(fun->isDeclaration() && !hasDefinition(fun))
-            return false;
-
-        const Function* funDef = fun;
-        if(fun->isDeclaration() && hasDefinition(fun))
-            funDef = getDefinition(fun);
-
-        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-        return it != FunDefToDeclsMap.end();
-    }
-
-    const FunctionSetType& getDeclaration(const Function* fun) const
-    {
-        const Function* funDef = fun;
-        if(fun->isDeclaration() && hasDefinition(fun))
-            funDef = getDefinition(fun);
-
-        FunDefToDeclsMapTy::const_iterator it = FunDefToDeclsMap.find(funDef);
-        assert(it != FunDefToDeclsMap.end() && "does not have a function definition (body)?");
-        return it->second;
-    }
-
-    /// Global to rep
-    bool hasGlobalRep(const GlobalVariable* val) const
-    {
-        GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
-        return it != GlobalDefToRepMap.end();
-    }
-
-    GlobalVariable *getGlobalRep(const GlobalVariable* val) const
-    {
-        GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
-        assert(it != GlobalDefToRepMap.end() && "has no rep?");
-        return it->second;
-    }
-
-
-    Module* getMainLLVMModule() const
-    {
-        return getModule(0);
-    }
-
-    LLVMContext& getContext() const
-    {
-        assert(!empty() && "empty LLVM module!!");
-        return getMainLLVMModule()->getContext();
-    }
-
-    bool empty() const
-    {
-        return getModuleNum() == 0;
-    }
-
-private:
-    std::vector<const Function*> getLLVMGlobalFunctions(const GlobalVariable* global);
-
-    void loadModules(const std::vector<std::string>& moduleNameVec);
-    void addSVFMain();
-
-    void createSVFDataStructure();
-    void initSVFFunction();
-    void initSVFBasicBlock(const SVFFunction* func);
-    void initDomTree(const SVFFunction* func);
-    void setValueAttr(const Value* val, SVFValue* value);
-    void buildFunToFunMap();
-    void buildGlobalDefToRepMap();
-    /// Invoke llvm passes to modify module
-    void prePassSchedule();
-    bool preProcessed;
-};
-
-} // End namespace SVF
-
-#endif /* INCLUDE_SVF_FE_LLVMMODULE_H_ */

package/SVF-linux/include/SVF-FE/LLVMUtil.h

@@ -1,303 +0,0 @@
-//===- LLVMUtil.h -- Analysis helper functions----------------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013->  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * LLVMUtil.h
- *
- *  Created on: Apr 11, 2013
- *      Author: Yulei Sui
- */
-
-#ifndef INCLUDE_SVF_FE_LLVMUTIL_H_
-#define INCLUDE_SVF_FE_LLVMUTIL_H_
-
-#include "SVF-FE/BasicTypes.h"
-#include "Util/SVFUtil.h"
-#include "SVF-FE/BasicTypes.h"
-#include "Util/BasicTypes.h"
-#include "Util/ExtAPI.h"
-#include "Util/ThreadAPI.h"
-
-namespace SVF
-{
-
-namespace LLVMUtil
-{
-
-
-/// Check whether this value is a black hole
-inline bool isBlackholeSym(const Value* val)
-{
-    return (SVFUtil::isa<UndefValue>(val));
-}
-
-/// Check whether this value is a black hole
-inline bool isNullPtrSym(const Value* val)
-{
-    if (const Constant* v = SVFUtil::dyn_cast<Constant>(val))
-    {
-        return v->isNullValue() && v->getType()->isPointerTy();
-    }
-    return false;
-}
-
-/// Check whether this value points-to a constant object
-bool isConstantObjSym(const Value* val);
-
-static inline Type *getPtrElementType(const PointerType* pty)
-{
-#if (LLVM_VERSION_MAJOR < 14)
-    return pty->getElementType();
-#else
-    assert(!pty->isOpaque() && "Opaque Pointer is used, please recompile the source adding '-Xclang -no-opaque-pointers'");
-    return pty->getNonOpaquePointerElementType();
-#endif
-}
-
-/// Get the reference type of heap/static object from an allocation site.
-//@{
-inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
-{
-    const PointerType *refType = nullptr;
-    // Case 1: heap object held by *argument, we should get its element type.
-    if (SVFUtil::isHeapAllocExtCallViaArg(cs))
-    {
-        int argPos = SVFUtil::getHeapAllocHoldingArgPosition(cs);
-        const Value* arg = cs.getArgument(argPos);
-        if (const PointerType *argType = SVFUtil::dyn_cast<PointerType>(arg->getType()))
-            refType = SVFUtil::dyn_cast<PointerType>(getPtrElementType(argType));
-    }
-    // Case 2: heap/static object held by return value.
-    else
-    {
-        assert((SVFUtil::isStaticExtCall(cs) || SVFUtil::isHeapAllocExtCallViaRet(cs))
-               && "Must be heap alloc via ret, or static allocation site");
-        refType = SVFUtil::dyn_cast<PointerType>(cs.getType());
-    }
-    assert(refType && "Allocated object must be held by a pointer-typed value.");
-    return refType;
-}
-
-inline const PointerType *getRefTypeOfHeapAllocOrStatic(const SVFInstruction* inst)
-{
-    CallSite cs(inst);
-    return getRefTypeOfHeapAllocOrStatic(cs);
-}
-//@}
-
-/// Return true if this value refers to a object
-bool isObject (const Value*  ref);
-
-/// Method for dead function, which does not have any possible caller
-/// function address is not taken and never be used in call or invoke instruction
-//@{
-/// whether this is a function without any possible caller?
-bool isUncalledFunction (const Function*  fun);
-
-/// whether this is an argument in dead function
-inline bool ArgInDeadFunction (const Value*  val)
-{
-    return SVFUtil::isa<Argument>(val)
-           && isUncalledFunction(SVFUtil::cast<Argument>(val)->getParent());
-}
-//@}
-
-/// Return true if this is an argument of a program entry function (e.g. main)
-inline bool ArgInProgEntryFunction (const Value*  val)
-{
-    return SVFUtil::isa<Argument>(val)
-           && SVFUtil::isProgEntryFunction(SVFUtil::cast<Argument>(val)->getParent());
-}
-/// Return true if this is value in a dead function (function without any caller)
-bool isPtrInUncalledFunction (const Value*  value);
-//@}
-
-//@}
-
-/// Function does not have any possible caller in the call graph
-//@{
-/// Return true if the function does not have a caller (either it is a main function or a dead function)
-inline bool isNoCallerFunction (const Function*  fun)
-{
-    return isUncalledFunction(fun) || SVFUtil::isProgEntryFunction(fun);
-}
-
-/// Return true if the argument in a function does not have a caller
-inline bool isArgOfUncalledFunction (const Value*  val)
-{
-    return SVFUtil::isa<Argument>(val)
-           && isNoCallerFunction(SVFUtil::cast<Argument>(val)->getParent());
-}
-//@}
-
-/// Return true if the function has a return instruction reachable from function entry
-bool functionDoesNotRet (const Function*  fun);
-
-/// Get reachable basic block from function entry
-void getFunReachableBBs (const SVFFunction* svfFun, std::vector<const SVFBasicBlock*>& bbs);
-
-/// Strip off the constant casts
-const Value*  stripConstantCasts(const Value* val);
-
-/// Strip off the all casts
-const Value* stripAllCasts(const Value* val) ;
-
-/// Get the type of the heap allocation
-const Type *getTypeOfHeapAlloc(const SVFInstruction* inst) ;
-
-/// Return the bitcast instruction which is val's only use site, otherwise return nullptr
-const Value* getUniqueUseViaCastInst(const Value* val);
-
-/// Return corresponding constant expression, otherwise return nullptr
-//@{
-inline const ConstantExpr *isGepConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::GetElementPtr)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isInt2PtrConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::IntToPtr)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isPtr2IntConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::PtrToInt)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isCastConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::BitCast)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isSelectConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::Select)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isTruncConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::Trunc ||
-                constExpr->getOpcode() == Instruction::FPTrunc ||
-                constExpr->getOpcode() == Instruction::ZExt ||
-                constExpr->getOpcode() == Instruction::SExt ||
-                constExpr->getOpcode() == Instruction::FPExt)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isCmpConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if(constExpr->getOpcode() == Instruction::ICmp || constExpr->getOpcode() == Instruction::FCmp)
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isBinaryConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if((constExpr->getOpcode() >= Instruction::BinaryOpsBegin) && (constExpr->getOpcode() <= Instruction::BinaryOpsEnd))
-            return constExpr;
-    }
-    return nullptr;
-}
-
-inline const ConstantExpr *isUnaryConstantExpr(const Value* val)
-{
-    if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
-    {
-        if((constExpr->getOpcode() >= Instruction::UnaryOpsBegin) && (constExpr->getOpcode() <= Instruction::UnaryOpsEnd))
-            return constExpr;
-    }
-    return nullptr;
-}
-//@}
-
-inline static DataLayout* getDataLayout(Module* mod)
-{
-    static DataLayout *dl = nullptr;
-    if (dl == nullptr) dl = new DataLayout(mod);
-    return dl;
-}
-
-/// Get the next instructions following control flow
-void getNextInsts(const SVFInstruction* curInst, std::vector<const SVFInstruction*>& instList);
-
-/// Get the previous instructions following control flow
-void getPrevInsts(const SVFInstruction* curInst, std::vector<const SVFInstruction*>& instList);
-
-/// Get num of BB's predecessors
-u32_t getBBPredecessorNum(const BasicBlock* BB);
-
-
-
-/// Check whether a file is an LLVM IR file
-bool isIRFile(const std::string &filename);
-
-/// Parse argument for multi-module analysis
-void processArguments(int argc, char **argv, int &arg_num, char **arg_value,
-                      std::vector<std::string> &moduleNameVec);
-
-/// Helper method to get the size of the type from target data layout
-//@{
-u32_t getTypeSizeInBytes(const Type* type);
-u32_t getTypeSizeInBytes(const StructType *sty, u32_t field_index);
-//@}
-
-
-} // End namespace LLVMUtil
-
-} // End namespace SVF
-
-#endif /* INCLUDE_SVF_FE_LLVMUTIL_H_ */

package/SVF-linux/include/SVF-FE/LocMemModel.h

@@ -1,35 +0,0 @@
-//===- LocMemModel.h -- Location set based memory model-----------------------//
-//
-//                     SVF: Static Value-Flow Analysis
-//
-// Copyright (C) <2013-2017>  <Yulei Sui>
-//
-
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-//===----------------------------------------------------------------------===//
-
-/*
- * LocMemModel.h
- *
- *  Created on: Apr 28, 2014
- *      Author: Yulei
- */
-
-#ifndef LOCMEMMODEL_H_
-#define LOCMEMMODEL_H_
-
-
-
-#endif /* LOCMEMMODEL_H_ */