svf-lib 1.0.1277 → 1.0.1279

package/SVF-linux/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-linux/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);
 
 
 

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

@@ -83,7 +83,7 @@ public:
     /// Get different kinds of node
     //@{
     // GetValNode - Return the value node according to a LLVM Value.
-    NodeID getValueNode(const Value *V)
+    NodeID getValueNode(const Value* V)
     {
         // first handle gep edge if val if a constant expression
         processCE(V);
@@ -93,7 +93,7 @@ public:
     }
 
     /// GetObject - Return the object node (stack/global/heap/function) according to a LLVM Value
-    inline NodeID getObjectNode(const Value *V)
+    inline NodeID getObjectNode(const Value* V)
     {
         return pag->getObjectNode(V);
     }
@@ -122,18 +122,9 @@ public:
     void visitStoreInst(StoreInst &I);
     void visitLoadInst(LoadInst &I);
     void visitGetElementPtrInst(GetElementPtrInst &I);
-    void visitCallInst(CallInst &I)
-    {
-        visitCallSite(&I);
-    }
-    void visitInvokeInst(InvokeInst &II)
-    {
-        visitCallSite(&II);
-    }
-    void visitCallBrInst(CallBrInst &I)
-    {
-        return visitCallSite(&I);
-    }
+    void visitCallInst(CallInst &I);
+    void visitInvokeInst(InvokeInst &II);
+    void visitCallBrInst(CallBrInst &I);
     void visitCallSite(CallSite cs);
     void visitReturnInst(ReturnInst &I);
     void visitCastInst(CastInst &I);
@@ -218,7 +209,7 @@ protected:
     //@}
 
     /// Process constant expression
-    void processCE(const Value *val);
+    void processCE(const Value* val);
 
     /// Infer field index from byteoffset.
     u32_t inferFieldIdxFromByteOffset(const llvm::GEPOperator* gepOp, DataLayout *dl, LocationSet& ls, s32_t idx);
@@ -230,7 +221,7 @@ protected:
     const Value* getBaseValueForExtArg(const Value* V);
 
     /// Get the base type and max offset
-    const Type *getBaseTypeAndFlattenedFields(const Value *V, std::vector<LocationSet> &fields, const Value* sz);
+    const Type *getBaseTypeAndFlattenedFields(const Value* V, std::vector<LocationSet> &fields, const Value* sz);
 
     /// Handle direct call
     void handleDirectCall(CallSite cs, const SVFFunction *F);
@@ -242,7 +233,7 @@ protected:
     //@{
     virtual void parseOperations(std::vector<ExtAPI::Operation>  &operations, CallSite cs);
     virtual void handleExtCall(CallSite cs, const SVFFunction *F);
-    void addComplexConsForExt(Value *D, Value *S, const Value* sz);
+    void addComplexConsForExt(const Value* D, const Value* S, const Value* sz);
     //@}
 
     /// Set current basic block in order to keep track of control flow information
@@ -251,11 +242,11 @@ protected:
         curBB = bb;
         curVal = val;
     }
-    inline const Value *getCurrentValue() const
+    inline const Value* getCurrentValue() const
     {
         return curVal;
     }
-    inline const BasicBlock *getCurrentBB() const
+    inline const BasicBlock* getCurrentBB() const
     {
         return curBB;
     }
@@ -359,8 +350,11 @@ protected:
     inline void addStoreEdge(NodeID src, NodeID dst)
     {
         IntraICFGNode* node;
-        if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(curVal))
+        if(const Instruction* i = SVFUtil::dyn_cast<Instruction>(curVal))
+        {
+            const SVFInstruction* inst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(i);
             node = pag->getICFG()->getIntraICFGNode(inst);
+        }
         else
             node = nullptr;
         if(StoreStmt *edge = pag->addStoreStmt(src, dst, node))

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

@@ -56,30 +56,30 @@ public:
 
     /// collect the syms
     //@{
-    void collectNullPtrBlackholeSyms(const Value *val);
+    void collectNullPtrBlackholeSyms(const Value* val);
 
     void collectSpecialSym(const Value* val);
 
-    void collectSym(const Value *val);
+    void collectSym(const Value* val);
 
-    void collectVal(const Value *val);
+    void collectVal(const Value* val);
 
-    void collectObj(const Value *val);
+    void collectObj(const Value* val);
 
-    void collectRet(const Function *val);
+    void collectRet(const Function* val);
 
-    void collectVararg(const Function *val);
+    void collectVararg(const Function* val);
     //@}
 
     /// Handle constant expression
     // @{
     void handleGlobalCE(const GlobalVariable *G);
     void handleGlobalInitializerCE(const Constant *C);
-    void handleCE(const Value *val);
+    void handleCE(const Value* val);
     // @}
 
     /// Create an objectInfo based on LLVM value
-    ObjTypeInfo* createObjTypeInfo(const Value *val);
+    ObjTypeInfo* createObjTypeInfo(const Value* val);
 
     /// Initialize TypeInfo based on LLVM Value
     void initTypeInfo(ObjTypeInfo* typeinfo, const Value* value);