svf-lib 1.0.1276 → 1.0.1278

package/SVF-osx/include/SVF-FE/DCHG.h

@@ -172,13 +172,13 @@ public:
     }
 
     /// Returns the vector of virtual function vectors.
-    const std::vector<std::vector<const Function *>> &getVfnVectors(void) const
+    const std::vector<std::vector<const Function* >> &getVfnVectors(void) const
     {
         return vfnVectors;
     }
 
     /// Return the nth virtual function vector in the vtable.
-    std::vector<const Function *> &getVfnVector(unsigned n)
+    std::vector<const Function* > &getVfnVector(unsigned n)
     {
         if (vfnVectors.size() < n + 1)
         {
@@ -197,7 +197,7 @@ private:
     std::string typeName;
     size_t flags;
     /// The virtual functions which this class actually defines/overrides.
-    std::vector<const Function *> primaryVTable;
+    std::vector<const Function* > primaryVTable;
     /// If a vtable is split into more than one vfn vector for multiple inheritance,
     /// 0 would be the primary base + this classes virtual functions, 1 would be
     /// the second parent, 2 would be third parent, etc.
@@ -406,7 +406,7 @@ private:
     /// Retrieves the metadata associated with a *virtual* callsite.
     const DIType *getCSStaticType(CallSite cs) const
     {
-        MDNode *md = cs.getInstruction()->getMetadata(cppUtil::ctir::derefMDName);
+        MDNode *md = cs.getInstruction()->getLLVMInstruction()->getMetadata(cppUtil::ctir::derefMDName);
         assert(md != nullptr && "Missing type metadata at virtual callsite");
         DIType *diType = SVFUtil::dyn_cast<DIType>(md);
         assert(diType != nullptr && "Incorrect metadata type at virtual callsite");

package/SVF-osx/include/SVF-FE/DataFlowUtil.h

@@ -75,7 +75,7 @@ public:
     const SCEV *scev;
     const Value* start;
     const Value* step;
-    const Value *ptr;
+    const Value* ptr;
     bool inloop;
     unsigned tripcount;
 

package/SVF-osx/include/SVF-FE/GEPTypeBridgeIterator.h

@@ -95,7 +95,7 @@ public:
         return operator*();
     }
 
-    Value *getOperand() const
+    Value* getOperand() const
     {
         return const_cast<Value*>(&**OpIt);
     }

package/SVF-osx/include/SVF-FE/ICFGBuilder.h

@@ -41,14 +41,14 @@ class ICFGBuilder
 
 public:
 
-    typedef std::vector<const Instruction*> InstVec;
-    typedef Set<const Instruction*> BBSet;
+    typedef std::vector<const SVFInstruction*> InstVec;
+    typedef Set<const SVFInstruction*> BBSet;
 
 private:
     ICFG* icfg;
 
 public:
-    typedef FIFOWorkList<const Instruction*> WorkList;
+    typedef FIFOWorkList<const SVFInstruction*> WorkList;
 
     ICFGBuilder(ICFG* i): icfg(i)
     {
@@ -69,10 +69,10 @@ private:
     void connectGlobalToProgEntry(SVFModule* svfModule);
 
     /// Add/Get an inter block ICFGNode
-    InterICFGNode* getOrAddInterBlockICFGNode(const Instruction* inst);
+    InterICFGNode* getOrAddInterBlockICFGNode(const SVFInstruction* inst);
 
     /// Add/Get a basic block ICFGNode
-    inline ICFGNode* getOrAddBlockICFGNode(const Instruction* inst)
+    inline ICFGNode* getOrAddBlockICFGNode(const SVFInstruction* inst)
     {
         if(SVFUtil::isNonInstricCallSite(inst))
             return getOrAddInterBlockICFGNode(inst);
@@ -81,21 +81,21 @@ private:
     }
 
     /// Create edges between ICFG nodes across functions
-    void addICFGInterEdges(const Instruction*  cs, const SVFFunction*  callee);
+    void addICFGInterEdges(const SVFInstruction*  cs, const SVFFunction*  callee);
 
     /// Add a call node
-    inline CallICFGNode* getCallICFGNode(const Instruction*  cs)
+    inline CallICFGNode* getCallICFGNode(const SVFInstruction*  cs)
     {
         return icfg->getCallICFGNode(cs);
     }
     /// Add a return node
-    inline RetICFGNode* getRetICFGNode(const Instruction*  cs)
+    inline RetICFGNode* getRetICFGNode(const SVFInstruction*  cs)
     {
         return icfg->getRetICFGNode(cs);
     }
 
     /// Add and get IntraBlock ICFGNode
-    IntraICFGNode* getOrAddIntraBlockICFGNode(const Instruction* inst)
+    IntraICFGNode* getOrAddIntraBlockICFGNode(const SVFInstruction* inst)
     {
         return icfg->getIntraICFGNode(inst);
     }

package/SVF-osx/include/SVF-FE/IRAnnotator.h

@@ -108,17 +108,17 @@ private:
     }
 
     // Deduce the LLVM value's type, and process the metadata accordingly
-    void processPAGNode(const Value *value, SVF::NodeID nodeId, bool writeFlag)
+    void processPAGNode(const Value* value, SVF::NodeID nodeId, bool writeFlag)
     {
-        if (auto instruction = const_cast<Instruction *>(SVFUtil::dyn_cast<Instruction>(value)))
+        if (auto instruction = const_cast<Instruction* >(SVFUtil::dyn_cast<Instruction>(value)))
         {
             processInstructionNode(instruction, nodeId, writeFlag);
         }
-        else if (auto argument = const_cast<Argument *>(SVFUtil::dyn_cast<Argument>(value)))
+        else if (auto argument = const_cast<Argument* >(SVFUtil::dyn_cast<Argument>(value)))
         {
             processArgumentNode(argument, nodeId, writeFlag);
         }
-        else if (auto function = const_cast<Function *>(SVFUtil::dyn_cast<Function>(value)))
+        else if (auto function = const_cast<Function* >(SVFUtil::dyn_cast<Function>(value)))
         {
             processFunctionNode(function, nodeId, writeFlag);
         }
@@ -126,7 +126,7 @@ private:
         {
             processGlobalVarNode(globalVar, nodeId, writeFlag);
         }
-        else if (auto basicBlock = const_cast<BasicBlock *>(SVFUtil::dyn_cast<BasicBlock>(value)))
+        else if (auto basicBlock = const_cast<BasicBlock* >(SVFUtil::dyn_cast<BasicBlock>(value)))
         {
             processBasicBlockNode(basicBlock, nodeId, writeFlag);
         }
@@ -145,7 +145,7 @@ private:
         }
     }
 
-    void processInstructionNode(Instruction *instruction, const SVF::NodeID &nodeId, bool writeFlag)
+    void processInstructionNode(Instruction* instruction, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "inode-" + std::to_string(nodeId);
 
@@ -163,7 +163,7 @@ private:
         }
     }
 
-    void processArgumentNode(Argument *argument, const SVF::NodeID &nodeId, bool writeFlag)
+    void processArgumentNode(Argument* argument, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "anode-" + std::to_string(nodeId);
 
@@ -181,7 +181,7 @@ private:
         }
     }
 
-    void processFunctionNode(Function *function, const SVF::NodeID &nodeId, bool writeFlag)
+    void processFunctionNode(Function* function, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "fnode-" + std::to_string(nodeId);
 
@@ -217,7 +217,7 @@ private:
         }
     }
 
-    void processBasicBlockNode(BasicBlock *basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
+    void processBasicBlockNode(BasicBlock* basicBlock, const SVF::NodeID &nodeId, bool writeFlag)
     {
         std::string label = "bnode-" + std::to_string(nodeId);
 

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

@@ -47,8 +47,16 @@ public:
     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;
+    static LLVMModuleSet* llvmModuleSet;
     SVFModule* svfModule;
     std::unique_ptr<LLVMContext> cxts;
     std::vector<std::unique_ptr<Module>> owned_modules;
@@ -61,13 +69,21 @@ private:
     /// 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()
+    static inline LLVMModuleSet* getLLVMModuleSet()
     {
         if (llvmModuleSet == nullptr)
             llvmModuleSet = new LLVMModuleSet();
@@ -81,8 +97,8 @@ public:
         llvmModuleSet = nullptr;
     }
 
-    SVFModule* buildSVFModule(Module &mod);
-    SVFModule* buildSVFModule(const std::vector<std::string> &moduleNameVec);
+    SVFModule* buildSVFModule(Module& mod);
+    SVFModule* buildSVFModule(const std::vector<std::string>& moduleNameVec);
 
     inline SVFModule* getSVFModule()
     {
@@ -90,13 +106,18 @@ public:
         return svfModule;
     }
 
-    void preProcessBCs(std::vector<std::string> &moduleNameVec);
+    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);
@@ -111,19 +132,91 @@ public:
     // Dump modules to files
     void dumpModulesToFile(const std::string suffix);
 
-    const SVFFunction *getSVFFunction(const Function *fun) const
+    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)
     {
-        return svfModule->getSVFFunction(fun);
+        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)
+    inline const SVFFunction* getSVFFunction(std::string name)
     {
-        Function *fun = nullptr;
+        Function* fun = nullptr;
 
         for (u32_t i = 0; i < llvmModuleSet->getModuleNum(); ++i)
         {
-            Module *mod = llvmModuleSet->getModule(i);
+            Module* mod = llvmModuleSet->getModule(i);
             fun = mod->getFunction(name);
             if (fun)
             {
@@ -133,14 +226,14 @@ public:
         return nullptr;
     }
 
-    bool hasDefinition(const Function *fun) const
+    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
+    const Function* getDefinition(const Function* fun) const
     {
         assert(fun->isDeclaration() && "not a function declaration?");
         FunDeclToDefMapTy::const_iterator it = FunDeclToDefMap.find(fun);
@@ -148,7 +241,7 @@ public:
         return it->second;
     }
 
-    bool hasDeclaration(const Function *fun) const
+    bool hasDeclaration(const Function* fun) const
     {
         if(fun->isDeclaration() && !hasDefinition(fun))
             return false;
@@ -161,7 +254,7 @@ public:
         return it != FunDefToDeclsMap.end();
     }
 
-    const FunctionSetType& getDeclaration(const Function *fun) const
+    const FunctionSetType& getDeclaration(const Function* fun) const
     {
         const Function* funDef = fun;
         if(fun->isDeclaration() && hasDefinition(fun))
@@ -173,13 +266,13 @@ public:
     }
 
     /// Global to rep
-    bool hasGlobalRep(const GlobalVariable *val) const
+    bool hasGlobalRep(const GlobalVariable* val) const
     {
         GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
         return it != GlobalDefToRepMap.end();
     }
 
-    GlobalVariable *getGlobalRep(const GlobalVariable *val) const
+    GlobalVariable *getGlobalRep(const GlobalVariable* val) const
     {
         GlobalDefToRepMapTy::const_iterator it = GlobalDefToRepMap.find(val);
         assert(it != GlobalDefToRepMap.end() && "has no rep?");
@@ -187,7 +280,7 @@ public:
     }
 
 
-    Module *getMainLLVMModule() const
+    Module* getMainLLVMModule() const
     {
         return getModule(0);
     }
@@ -204,12 +297,16 @@ public:
     }
 
 private:
-    std::vector<const Function *> getLLVMGlobalFunctions(
-        const GlobalVariable *global);
+    std::vector<const Function*> getLLVMGlobalFunctions(const GlobalVariable* global);
 
-    void loadModules(const std::vector<std::string> &moduleNameVec);
+    void loadModules(const std::vector<std::string>& moduleNameVec);
     void addSVFMain();
-    void initialize();
+
+    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
@@ -219,4 +316,4 @@ private:
 
 } // End namespace SVF
 
-#endif /* INCLUDE_SVF_FE_LLVMMODULE_H_ */
+#endif /* INCLUDE_SVF_FE_LLVMMODULE_H_ */

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

@@ -45,13 +45,13 @@ namespace LLVMUtil
 
 
 /// Check whether this value is a black hole
-inline bool isBlackholeSym(const Value *val)
+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)
+inline bool isNullPtrSym(const Value* val)
 {
     if (const Constant* v = SVFUtil::dyn_cast<Constant>(val))
     {
@@ -61,14 +61,7 @@ inline bool isNullPtrSym(const Value *val)
 }
 
 /// Check whether this value points-to a constant object
-bool isConstantObjSym(const Value *val);
-
-
-/// Whether an instruction is a return instruction
-inline bool isReturn(const Instruction* inst)
-{
-    return SVFUtil::isa<ReturnInst>(inst);
-}
+bool isConstantObjSym(const Value* val);
 
 static inline Type *getPtrElementType(const PointerType* pty)
 {
@@ -89,7 +82,7 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
     if (SVFUtil::isHeapAllocExtCallViaArg(cs))
     {
         int argPos = SVFUtil::getHeapAllocHoldingArgPosition(cs);
-        const Value *arg = cs.getArgument(argPos);
+        const Value* arg = cs.getArgument(argPos);
         if (const PointerType *argType = SVFUtil::dyn_cast<PointerType>(arg->getType()))
             refType = SVFUtil::dyn_cast<PointerType>(getPtrElementType(argType));
     }
@@ -104,24 +97,24 @@ inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
     return refType;
 }
 
-inline const PointerType *getRefTypeOfHeapAllocOrStatic(const Instruction *inst)
+inline const PointerType *getRefTypeOfHeapAllocOrStatic(const SVFInstruction* inst)
 {
-    CallSite cs(const_cast<Instruction*>(inst));
+    CallSite cs(inst);
     return getRefTypeOfHeapAllocOrStatic(cs);
 }
 //@}
 
 /// Return true if this value refers to a object
-bool isObject (const Value * ref);
+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);
+bool isUncalledFunction (const Function*  fun);
 
 /// whether this is an argument in dead function
-inline bool ArgInDeadFunction (const Value * val)
+inline bool ArgInDeadFunction (const Value*  val)
 {
     return SVFUtil::isa<Argument>(val)
            && isUncalledFunction(SVFUtil::cast<Argument>(val)->getParent());
@@ -129,13 +122,13 @@ inline bool ArgInDeadFunction (const Value * val)
 //@}
 
 /// Return true if this is an argument of a program entry function (e.g. main)
-inline bool ArgInProgEntryFunction (const Value * val)
+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);
+bool isPtrInUncalledFunction (const Value*  value);
 //@}
 
 //@}
@@ -143,13 +136,13 @@ 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)
+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)
+inline bool isArgOfUncalledFunction (const Value*  val)
 {
     return SVFUtil::isa<Argument>(val)
            && isNoCallerFunction(SVFUtil::cast<Argument>(val)->getParent());
@@ -157,34 +150,26 @@ inline bool isArgOfUncalledFunction (const Value * val)
 //@}
 
 /// Return true if the function has a return instruction reachable from function entry
-bool functionDoesNotRet (const Function * fun);
+bool functionDoesNotRet (const Function*  fun);
 
 /// Get reachable basic block from function entry
-void getFunReachableBBs (const SVFFunction* svfFun, std::vector<const BasicBlock*>& bbs);
+void getFunReachableBBs (const SVFFunction* svfFun, std::vector<const SVFBasicBlock*>& bbs);
 
-/// Get function exit basic block
-/// FIXME: this back() here is only valid when UnifyFunctionExitNodes pass is invoked
-inline const BasicBlock* getFunExitBB(const SVFFunction* svfFun)
-{
-    const Function* fun = svfFun->getLLVMFun();
-    assert(!SVFUtil::isExtCall(svfFun) && "The function cannot be an external call");
-    return &fun->back();
-}
 /// Strip off the constant casts
-const Value * stripConstantCasts(const Value *val);
+const Value*  stripConstantCasts(const Value* val);
 
 /// Strip off the all casts
-const Value *stripAllCasts(const Value *val) ;
+const Value* stripAllCasts(const Value* val) ;
 
 /// Get the type of the heap allocation
-const Type *getTypeOfHeapAlloc(const llvm::Instruction *inst) ;
+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)
+inline const ConstantExpr *isGepConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -194,7 +179,7 @@ inline const ConstantExpr *isGepConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isInt2PtrConstantExpr(const Value *val)
+inline const ConstantExpr *isInt2PtrConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -204,7 +189,7 @@ inline const ConstantExpr *isInt2PtrConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isPtr2IntConstantExpr(const Value *val)
+inline const ConstantExpr *isPtr2IntConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -214,7 +199,7 @@ inline const ConstantExpr *isPtr2IntConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isCastConstantExpr(const Value *val)
+inline const ConstantExpr *isCastConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -224,7 +209,7 @@ inline const ConstantExpr *isCastConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isSelectConstantExpr(const Value *val)
+inline const ConstantExpr *isSelectConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -234,7 +219,7 @@ inline const ConstantExpr *isSelectConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isTruncConstantExpr(const Value *val)
+inline const ConstantExpr *isTruncConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -248,7 +233,7 @@ inline const ConstantExpr *isTruncConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isCmpConstantExpr(const Value *val)
+inline const ConstantExpr *isCmpConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -258,7 +243,7 @@ inline const ConstantExpr *isCmpConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isBinaryConstantExpr(const Value *val)
+inline const ConstantExpr *isBinaryConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -268,7 +253,7 @@ inline const ConstantExpr *isBinaryConstantExpr(const Value *val)
     return nullptr;
 }
 
-inline const ConstantExpr *isUnaryConstantExpr(const Value *val)
+inline const ConstantExpr *isUnaryConstantExpr(const Value* val)
 {
     if(const ConstantExpr* constExpr = SVFUtil::dyn_cast<ConstantExpr>(val))
     {
@@ -287,19 +272,13 @@ inline static DataLayout* getDataLayout(Module* mod)
 }
 
 /// Get the next instructions following control flow
-void getNextInsts(const Instruction* curInst, std::vector<const Instruction*>& instList);
+void getNextInsts(const SVFInstruction* curInst, std::vector<const SVFInstruction*>& instList);
 
 /// Get the previous instructions following control flow
-void getPrevInsts(const Instruction* curInst, std::vector<const Instruction*>& instList);
-
-/// Get basic block successor position
-u32_t getBBSuccessorPos(const BasicBlock *BB, const BasicBlock *Succ);
-/// Get num of BB's successors
-u32_t getBBSuccessorNum(const BasicBlock *BB);
-/// Get basic block predecessor positin
-u32_t getBBPredecessorPos(const BasicBlock *BB, const BasicBlock *Pred);
+void getPrevInsts(const SVFInstruction* curInst, std::vector<const SVFInstruction*>& instList);
+
 /// Get num of BB's predecessors
-u32_t getBBPredecessorNum(const BasicBlock *BB);
+u32_t getBBPredecessorNum(const BasicBlock* BB);