svf-lib 1.0.1277 → 1.0.1279

package/SVF-linux/include/MTA/MTAResultValidator.h

@@ -52,15 +52,15 @@ protected:
     std::vector<std::string> split(const std::string &s, char delim);
 
     // Get special arguments of given call sites
-    NodeID getIntArg(const Instruction* inst, unsigned int arg_num);
-    std::vector<std::string> getStringArg(const Instruction* inst, unsigned int arg_num);
-    CallStrCxt getCxtArg(const Instruction* inst, unsigned int arg_num);
+    NodeID getIntArg(const SVFInstruction* inst, unsigned int arg_num);
+    std::vector<std::string> getStringArg(const SVFInstruction* inst, unsigned int arg_num);
+    CallStrCxt getCxtArg(const SVFInstruction* inst, unsigned int arg_num);
 
     /*
      * Get the previous LoadInst or StoreInst from Instruction "I" in the
      * same BasicBlock. Return nullptr if none exists.
      */
-    const Instruction *getPreviousMemoryAccessInst(const Instruction *I);
+    const Instruction* getPreviousMemoryAccessInst(const Instruction* I);
 
     // Compare two cxts
     bool matchCxt(const CallStrCxt cxt1, const CallStrCxt cxt2) const;
@@ -77,7 +77,7 @@ protected:
     /*
      * Collect the callsite targets for validations.
      * The targets are labeled by "cs1:", "cs2:"... that are the names of its basic blocks.
-     * The collected targets are stored in csnumToInstMap that maps label "cs1" to CallInst.
+     * The collected targets are stored in csnumToInstMap that maps label "cs1" to its Callsite.
      */
     bool collectCallsiteTargets();
 
@@ -117,7 +117,7 @@ protected:
 
 private:
 
-    typedef Map<NodeID, const CallInst*> csnumToInst;
+    typedef Map<NodeID, const SVFInstruction*> csnumToInst;
     typedef Map<NodeID, CallStrCxt> vthdToCxtMap;
     typedef Map<NodeID, NodeID> vthdTorthdMap;
     typedef Map<NodeID, NodeID> rthdTovthdMap;
@@ -177,7 +177,7 @@ public:
     {
     public:
         /// Constructor
-        AccessPair(const Instruction *I1, const Instruction *I2,
+        AccessPair(const Instruction* I1, const Instruction* I2,
                    const RC_FLAG flags) :
             I1(I1), I2(I2), flags(flags)
         {
@@ -189,19 +189,19 @@ public:
         {
             return flags & flag;
         }
-        inline const Instruction *getInstruction1() const
+        inline const Instruction* getInstruction1() const
         {
             return I1;
         }
-        inline const Instruction *getInstruction2() const
+        inline const Instruction* getInstruction2() const
         {
             return I2;
         }
         //@}
 
     private:
-        const Instruction *I1;
-        const Instruction *I2;
+        const Instruction* I1;
+        const Instruction* I2;
         RC_FLAG flags;
     };
 
@@ -240,26 +240,26 @@ protected:
     /// Interface to the specific validation properties.
     /// Override one or more to implement your own analysis.
     //@{
-    virtual bool mayAccessAliases(const Instruction *I1,
-                                  const Instruction *I2)
+    virtual bool mayAccessAliases(const Instruction* I1,
+                                  const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_ALIASES;
         return true;
     }
-    virtual bool mayHappenInParallel(const Instruction *I1,
-                                     const Instruction *I2)
+    virtual bool mayHappenInParallel(const Instruction* I1,
+                                     const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_MHP;
         return true;
     }
-    virtual bool protectedByCommonLocks(const Instruction *I1,
-                                        const Instruction *I2)
+    virtual bool protectedByCommonLocks(const Instruction* I1,
+                                        const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_PROTECTED;
         return true;
     }
-    virtual bool mayHaveDataRace(const Instruction *I1,
-                                 const Instruction *I2)
+    virtual bool mayHaveDataRace(const Instruction* I1,
+                                 const Instruction* I2)
     {
         selectedValidationScenarios &= ~RC_RACE;
         return true;
@@ -274,15 +274,18 @@ protected:
     void collectValidationTargets()
     {
         // Collect call sites of all RC_ACCESS function calls.
-        std::vector<const CallInst*> csInsts;
-        const Function *F = nullptr;
-        for(auto it = M->llvmFunBegin(); it != M->llvmFunEnd(); it++)
+        std::vector<CallSite> csInsts;
+        const Function* F = nullptr;
+        for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
         {
-            const std::string fName = (*it)->getName().str();
-            if(fName.find(RC_ACCESS) != std::string::npos)
+            for(auto it = M.begin(); it != M.end(); it++)
             {
-                F = (*it);
-                break;
+                const std::string fName = (*it).getName().str();
+                if(fName.find(RC_ACCESS) != std::string::npos)
+                {
+                    F = &(*it);
+                    break;
+                }
             }
         }
         if (!F)     return;
@@ -292,9 +295,11 @@ protected:
         {
             const Use *u = &*it;
             const Value *user = u->getUser();
-            const CallInst *csInst = SVFUtil::dyn_cast<CallInst>(user);
-            assert(csInst);
-            csInsts.push_back(csInst);
+            if(SVFUtil::isCallSite(user))
+            {
+                CallSite csInst = SVFUtil::getLLVMCallSite(user);
+                csInsts.push_back(csInst);
+            }
         }
         assert(csInsts.size() % 2 == 0 && "We should have RC_ACCESS called in pairs.");
 
@@ -304,12 +309,12 @@ protected:
         // Generate access pairs.
         for (int i = 0, e = csInsts.size(); i != e;)
         {
-            const CallInst *CI1 = csInsts[i++];
-            const CallInst *CI2 = csInsts[i++];
-            const ConstantInt *C = SVFUtil::dyn_cast<ConstantInt>(CI1->getOperand(1));
+            CallSite CI1 = csInsts[i++];
+            CallSite CI2 = csInsts[i++];
+            const ConstantInt* C = SVFUtil::dyn_cast<ConstantInt>(CI1.getArgOperand(1));
             assert(C);
-            const Instruction *I1 = getPreviousMemoryAccessInst(CI1);
-            const Instruction *I2 = getPreviousMemoryAccessInst(CI2);
+            const Instruction* I1 = getPreviousMemoryAccessInst(CI1.getInstruction()->getLLVMInstruction());
+            const Instruction* I2 = getPreviousMemoryAccessInst(CI2.getInstruction()->getLLVMInstruction());
             assert(I1 && I2 && "RC_ACCESS should be placed immediately after the target memory access.");
             RC_FLAG flags = C->getZExtValue();
             accessPairs.push_back(AccessPair(I1, I2, flags));
@@ -325,8 +330,8 @@ protected:
         for (int i = 0, e = accessPairs.size(); i != e; ++i)
         {
             const AccessPair &ap = accessPairs[i];
-            const Instruction *I1 = ap.getInstruction1();
-            const Instruction *I2 = ap.getInstruction2();
+            const Instruction* I1 = ap.getInstruction1();
+            const Instruction* I2 = ap.getInstruction2();
 
             bool mhp = mayHappenInParallel(I1, I2);
             bool alias = mayAccessAliases(I1, I2);
@@ -390,12 +395,12 @@ private:
      * Comparison function to sort the validation targets in ascending order of
      * the validation id (i.e., the 1st argument of RC_ACCESS function call).
      */
-    static bool compare(const CallInst *CI1, const CallInst *CI2)
+    static bool compare(CallSite CI1, CallSite CI2)
     {
-        const Value *V1 = CI1->getOperand(0);
-        const Value *V2 = CI2->getOperand(0);
-        const ConstantInt *C1 = SVFUtil::dyn_cast<ConstantInt>(V1);
-        const ConstantInt *C2 = SVFUtil::dyn_cast<ConstantInt>(V2);
+        const Value *V1 = CI1.getArgOperand(0);
+        const Value *V2 = CI2.getArgOperand(0);
+        const ConstantInt* C1 = SVFUtil::dyn_cast<ConstantInt>(V1);
+        const ConstantInt* C2 = SVFUtil::dyn_cast<ConstantInt>(V2);
         assert(0 != C1 && 0 != C2);
         return C1->getZExtValue() < C2->getZExtValue();
     }
@@ -405,8 +410,8 @@ private:
      * same BasicBlock.
      * Return nullptr if none exists.
      */
-    const Instruction *getPreviousMemoryAccessInst(
-        const Instruction *I)
+    const Instruction* getPreviousMemoryAccessInst(
+        const Instruction* I)
     {
         I = I->getPrevNode();
         while (I)
@@ -414,7 +419,9 @@ private:
             if (SVFUtil::isa<LoadInst>(I) || SVFUtil::isa<StoreInst>(I))
                 return I;
 
-            if (const SVFFunction *callee = SVFUtil::getCallee(I))
+            const SVFInstruction* inst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(I);
+
+            if (const SVFFunction *callee = SVFUtil::getCallee(inst))
             {
                 if (callee->getName().find("llvm.memset") != std::string::npos)
                     return I;

package/SVF-linux/include/MTA/PCG.h

@@ -51,11 +51,11 @@ class PCG
 {
 
 public:
-    typedef Set<const Function*> FunSet;
-    typedef std::vector<const Function*> FunVec;
-    typedef Set<const Instruction*> CallInstSet;
-    typedef FIFOWorkList<const Function*> FunWorkList;
-    typedef FIFOWorkList<const BasicBlock*> BBWorkList;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef std::vector<const SVFFunction*> FunVec;
+    typedef Set<const SVFInstruction*> CallInstSet;
+    typedef FIFOWorkList<const SVFFunction*> FunWorkList;
+    typedef FIFOWorkList<const SVFBasicBlock*> BBWorkList;
 
 private:
     FunSet spawners;
@@ -72,31 +72,31 @@ private:
 
     /// Add/Get methods for thread properties of a procedure
     //@{
-    inline bool isSpawnerFun(const Function* fun) const
+    inline bool isSpawnerFun(const SVFFunction* fun) const
     {
         return spawners.find(fun) != spawners.end();
     }
-    inline bool isSpawneeFun(const Function* fun) const
+    inline bool isSpawneeFun(const SVFFunction* fun) const
     {
         return spawnees.find(fun) != spawnees.end();
     }
-    inline bool isFollowerFun(const Function* fun) const
+    inline bool isFollowerFun(const SVFFunction* fun) const
     {
         return followers.find(fun) != followers.end();
     }
-    inline bool addSpawnerFun(const Function* fun)
+    inline bool addSpawnerFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
         return spawners.insert(fun).second;
     }
-    inline bool addSpawneeFun(const Function* fun)
+    inline bool addSpawneeFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
         return spawnees.insert(fun).second;
     }
-    inline bool addFollowerFun(const Function* fun)
+    inline bool addFollowerFun(const SVFFunction* fun)
     {
         if (fun->isDeclaration())
             return false;
@@ -106,11 +106,11 @@ private:
 
     /// Add/search spawn sites which directly or indirectly create a thread
     //@{
-    inline bool addSpawnsite(const Instruction* callInst)
+    inline bool addSpawnsite(const SVFInstruction* callInst)
     {
         return spawnCallSites.insert(callInst).second;
     }
-    inline bool isSpawnsite(const Instruction* callInst)
+    inline bool isSpawnsite(const SVFInstruction* callInst)
     {
         return spawnCallSites.find(callInst) != spawnCallSites.end();
     }
@@ -145,18 +145,13 @@ public:
     {
     }
 
-    CallICFGNode* getCallICFGNode(const Instruction* inst)
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
     {
         return pta->getICFG()->getCallICFGNode(inst);
     }
-    const SVFFunction* getSVFFun(const Function* fun) const
-    {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-    }
     /// Interface to query whether two function may happen-in-parallel
-    virtual bool mayHappenInParallel(const Instruction* i1, const Instruction* i2) const;
-    bool mayHappenInParallelBetweenFunctions(const Function* fun1, const Function* fun2) const;
-    //bool mayHappenInParallel(const Function* fun1, const Function* fun2) const;
+    virtual bool mayHappenInParallel(const SVFInstruction* i1, const SVFInstruction* i2) const;
+    bool mayHappenInParallelBetweenFunctions(const SVFFunction* fun1, const SVFFunction* fun2) const;
     inline const FunSet& getMHPFunctions() const
     {
         return mhpfuns;
@@ -192,27 +187,27 @@ public:
 
     /// Iterators for thread properties of a procedure
     //@{
-    inline FunSet::const_iterator spawnersBegin(const Function* fun) const
+    inline FunSet::const_iterator spawnersBegin(const SVFFunction* fun) const
     {
         return spawners.begin();
     }
-    inline FunSet::const_iterator spawnersEnd(const Function* fun) const
+    inline FunSet::const_iterator spawnersEnd(const SVFFunction* fun) const
     {
         return spawners.end();
     }
-    inline FunSet::const_iterator spawneesBegin(const Function* fun) const
+    inline FunSet::const_iterator spawneesBegin(const SVFFunction* fun) const
     {
         return spawnees.begin();
     }
-    inline FunSet::const_iterator spawneesEnd(const Function* fun) const
+    inline FunSet::const_iterator spawneesEnd(const SVFFunction* fun) const
     {
         return spawnees.end();
     }
-    inline FunSet::const_iterator followersBegin(const Function* fun) const
+    inline FunSet::const_iterator followersBegin(const SVFFunction* fun) const
     {
         return followers.begin();
     }
-    inline FunSet::const_iterator followersEnd(const Function* fun) const
+    inline FunSet::const_iterator followersEnd(const SVFFunction* fun) const
     {
         return followers.end();
     }

package/SVF-linux/include/MTA/TCT.h

@@ -51,7 +51,6 @@ typedef GenericEdge<TCTNode> GenericTCTEdgeTy;
 class TCTEdge: public GenericTCTEdgeTy
 {
 public:
-    typedef Set<const Instruction*> CallInstSet;
     enum CEDGEK
     {
         ThreadCreateEdge
@@ -140,14 +139,14 @@ class TCT: public GenericThreadCreateTreeTy
 public:
     typedef TCTEdge::ThreadCreateEdgeSet ThreadCreateEdgeSet;
     typedef ThreadCreateEdgeSet::iterator TCTNodeIter;
-    typedef Set<const Function*> FunSet;
-    typedef std::vector<const Instruction*> InstVec;
-    typedef Set<const Instruction*> InstSet;
+    typedef Set<const SVFFunction*> FunSet;
+    typedef std::vector<const SVFInstruction*> InstVec;
+    typedef Set<const SVFInstruction*> InstSet;
     typedef Set<const PTACallGraphNode*> PTACGNodeSet;
     typedef Map<CxtThread,TCTNode*> CxtThreadToNodeMap;
     typedef Map<CxtThread,CallStrCxt> CxtThreadToForkCxt;
-    typedef Map<CxtThread,const Function*> CxtThreadToFun;
-    typedef Map<const Instruction*, const Loop*> InstToLoopMap;
+    typedef Map<CxtThread,const SVFFunction*> CxtThreadToFun;
+    typedef Map<const SVFInstruction*, const Loop*> InstToLoopMap;
     typedef FIFOWorkList<CxtThreadProc> CxtThreadProcVec;
     typedef Set<CxtThreadProc> CxtThreadProcSet;
     typedef SCCDetection<PTACallGraph*> ThreadCallGraphSCC;
@@ -169,15 +168,10 @@ public:
         destroy();
     }
     /// Get CallICFGNode given inst
-    CallICFGNode* getCallICFGNode(const Instruction* inst)
+    CallICFGNode* getCallICFGNode(const SVFInstruction* inst)
     {
         return pta->getICFG()->getCallICFGNode(inst);
     }
-    /// Get SVFFuntion given Function
-    const SVFFunction* getSVFFun(const Function* fun) const
-    {
-        return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
-    }
     /// Get SVFFModule
     SVFModule* getSVFModule() const
     {
@@ -272,18 +266,14 @@ public:
         for(PTACallGraph::FunctionSet::const_iterator cit = callees.begin(),
                 ecit = callees.end(); cit!=ecit; cit++)
         {
-            if(candidateFuncSet.find((*cit)->getLLVMFun())!=candidateFuncSet.end())
+            if(candidateFuncSet.find((*cit))!=candidateFuncSet.end())
                 return true;
         }
         return false;
     }
-    inline bool isCandidateFun(const Function* fun) const
-    {
-        return candidateFuncSet.find(fun)!=candidateFuncSet.end();
-    }
     inline bool isCandidateFun(const SVFFunction* fun) const
     {
-        return isCandidateFun(fun->getLLVMFun());
+        return candidateFuncSet.find(fun)!=candidateFuncSet.end();
     }
     /// Whether two functions in the same callgraph scc
     inline bool inSameCallGraphSCC(const PTACallGraphNode* src,const PTACallGraphNode* dst)
@@ -357,7 +347,7 @@ public:
     }
 
     /// get the start routine function of a thread
-    const Function* getStartRoutineOfCxtThread(const CxtThread& ct) const
+    const SVFFunction* getStartRoutineOfCxtThread(const CxtThread& ct) const
     {
         CxtThreadToFun::const_iterator it = ctToRoutineFunMap.find(ct);
         assert(it!=ctToRoutineFunMap.end() && "Cxt Thread not found!!");
@@ -365,7 +355,7 @@ public:
     }
 
     /// Get loop for join site
-    inline const Loop* getJoinLoop(const Instruction* join)
+    inline const Loop* getJoinLoop(const SVFInstruction* join)
     {
         assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
         InstToLoopMap::const_iterator it = joinSiteToLoopMap.find(join);
@@ -374,24 +364,24 @@ public:
         return nullptr;
     }
     /// Return true if a join instruction must be executed inside a loop
-    bool isJoinMustExecutedInLoop(const Loop* lp,const Instruction* join);
+    bool isJoinMustExecutedInLoop(const Loop* lp,const SVFInstruction* join);
     /// Get loop for an instruction
-    const Loop* getLoop(const Instruction* inst);
+    const Loop* getLoop(const SVFInstruction* inst);
     /// Get dominator for a function
     const DominatorTree* getDT(const Function* fun);
     /// Get dominator for a function
     const PostDominatorTree* getPostDT(const Function* fun);
     /// Get loop for fork/join site
-    const Loop* getLoop(const BasicBlock* bb);
+    const Loop* getLoop(const SVFBasicBlock* bb);
     /// Get SE for function
-    ScalarEvolution* getSE(const Instruction* inst);
+    ScalarEvolution* getSE(const SVFInstruction* inst);
 
     /// Get the next instructions following control flow
-    void getNextInsts(const Instruction* inst, InstVec& instSet);
+    void getNextInsts(const SVFInstruction* inst, InstVec& instSet);
     /// Push calling context
-    void pushCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
     /// Match context
-    bool matchCxt(CallStrCxt& cxt, const Instruction* call, const Function* callee);
+    bool matchCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
 
     inline void pushCxt(CallStrCxt& cxt, CallSiteID csId)
     {
@@ -400,7 +390,7 @@ public:
             MaxCxtSize = cxt.size();
     }
     /// Whether a join site is in recursion
-    inline bool isJoinSiteInRecursion(const Instruction* join) const
+    inline bool isJoinSiteInRecursion(const SVFInstruction* join) const
     {
         assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
         return inRecurJoinSites.find(join)!=inRecurJoinSites.end();
@@ -452,7 +442,7 @@ private:
     /// Mark relevant procedures that are backward reachable from any fork/join site
     //@{
     void markRelProcs();
-    void markRelProcs(const Function* fun);
+    void markRelProcs(const SVFFunction* fun);
     //@}
 
     /// Get entry functions that are neither called by other functions nor extern functions
@@ -467,17 +457,17 @@ private:
     /// collect loop info for join sites
     void collectLoopInfoForJoin();
     /// Whether a given bb is a loop head of a inloop join site
-    bool isLoopHeaderOfJoinLoop(const BasicBlock* bb);
+    bool isLoopHeaderOfJoinLoop(const SVFBasicBlock* bb);
     /// Whether a given bb is an exit of a inloop join site
-    bool isLoopExitOfJoinLoop(const BasicBlock* bb);
+    bool isLoopExitOfJoinLoop(const SVFBasicBlock* bb);
     //@}
 
     /// Multi-forked threads
     //@{
     /// Whether an instruction is in a loop
-    bool isInLoopInstruction(const Instruction* inst);
+    bool isInLoopInstruction(const SVFInstruction* inst);
     /// Whether an instruction is in a recursion
-    bool isInRecursion(const Instruction* inst) const;
+    bool isInRecursion(const SVFInstruction* inst) const;
     //@}
 
     /// Handle call relations
@@ -485,7 +475,7 @@ private:
 
     /// Get or create a tct node based on CxtThread
     //@{
-    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const CallInst* fork,const CallStrCxt& oldCxt, const Function* routine)
+    inline TCTNode* getOrCreateTCTNode(const CallStrCxt& cxt, const SVFInstruction* fork,const CallStrCxt& oldCxt, const SVFFunction* routine)
     {
         CxtThread ct(cxt,fork);
         CxtThreadToNodeMap::const_iterator it = ctpToNodeMap.find(ct);
@@ -508,8 +498,9 @@ private:
         /// non-main thread
         if(ct.getThread() != nullptr)
         {
-            ct.setInloop(isInLoopInstruction(ct.getThread()));
-            ct.setIncycle(isInRecursion(ct.getThread()));
+            const SVFInstruction* svfInst = ct.getThread();
+            ct.setInloop(isInLoopInstruction(svfInst));
+            ct.setIncycle(isInRecursion(svfInst));
         }
         /// main thread
         else
@@ -525,7 +516,7 @@ private:
         ctToForkCxtMap[ct] = cxt;
     }
     /// Add start routine function of a cxt thread
-    void addStartRoutineOfCxtThread(const Function* fun, const CxtThread& ct)
+    void addStartRoutineOfCxtThread(const SVFFunction* fun, const CxtThread& ct)
     {
         ctToRoutineFunMap[ct] = fun;
     }

package/SVF-linux/include/MemoryModel/SVFStatements.h

@@ -58,7 +58,7 @@ public:
 
 private:
     const Value* value;	///< LLVM value
-    const BasicBlock *basicBlock;   ///< LLVM BasicBlock
+    const SVFBasicBlock* basicBlock;   ///< LLVM BasicBlock
     ICFGNode *icfgNode;   ///< ICFGNode
     EdgeID edgeId;					///< Edge ID
 public:
@@ -104,11 +104,16 @@ public:
 
     /// Get/set methods for llvm instruction
     //@{
-    inline const Instruction* getInst() const
+    inline const SVFInstruction* getInst() const
     {
-        return SVFUtil::dyn_cast<Instruction>(value);
+        if(const Instruction* i = SVFUtil::dyn_cast<Instruction>(value))
+        {
+            return LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(i);
+        }
+        else
+            return nullptr;
     }
-    inline void setValue(const Value *val)
+    inline void setValue(const Value* val)
     {
         value = val;
     }
@@ -116,11 +121,11 @@ public:
     {
         return value;
     }
-    inline void setBB(const BasicBlock *bb)
+    inline void setBB(const SVFBasicBlock* bb)
     {
         basicBlock = bb;
     }
-    inline const BasicBlock* getBB() const
+    inline const SVFBasicBlock* getBB() const
     {
         return basicBlock;
     }

package/SVF-linux/include/MemoryModel/SVFVariables.h

@@ -124,16 +124,16 @@ public:
     virtual const std::string getValueName() const = 0;
 
     /// Return the function that this SVFVar resides in. Return nullptr if it is a global or constantexpr node
-    virtual inline const Function* getFunction() const
+    virtual inline const SVFFunction* getFunction() const
     {
         if(value)
         {
             if(const Instruction* inst = SVFUtil::dyn_cast<Instruction>(value))
-                return inst->getParent()->getParent();
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(inst->getParent()->getParent());
             else if (const Argument* arg = SVFUtil::dyn_cast<Argument>(value))
-                return arg->getParent();
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(arg->getParent());
             else if (const Function* fun = SVFUtil::dyn_cast<Function>(value))
-                return fun;
+                return LLVMModuleSet::getLLVMModuleSet()->getSVFFunction(fun);
         }
         return nullptr;
     }

package/SVF-linux/include/MemoryModel/SymbolTableInfo.h

@@ -67,17 +67,14 @@ public:
     //{@
     /// llvm value to sym id map
     /// local (%) and global (@) identifiers are pointer types which have a value node id.
-    typedef OrderedMap<const Value *, SymID> ValueToIDMapTy;
+    typedef OrderedMap<const Value*, SymID> ValueToIDMapTy;
     /// sym id to memory object map
     typedef OrderedMap<SymID,MemObj*> IDToMemMapTy;
     /// function to sym id map
-    typedef OrderedMap<const Function *, SymID> FunToIDMapTy;
+    typedef OrderedMap<const SVFFunction*, SymID> FunToIDMapTy;
     /// struct type to struct info map
     typedef OrderedMap<const Type*, StInfo*> TypeToFieldInfoMap;
     typedef Set<CallSite> CallSiteSet;
-    typedef OrderedMap<const Instruction*,CallSiteID> CallSiteToIDMapTy;
-    typedef OrderedMap<CallSiteID,const Instruction*> IDToCallSiteMapTy;
-
     //@}
 
 private:
@@ -161,15 +158,12 @@ public:
 
     /// special value
     // @{
-    static bool isNullPtrSym(const Value *val);
-    static bool isBlackholeSym(const Value *val);
-    static bool isArgOfUncalledFunction(const Value *val);
-    static bool isReturn(const Instruction *inst);
-    static bool isPtrInUncalledFunction (const Value * value);
-    static const u32_t getBBSuccessorNum(const BasicBlock *bb);
+    static bool isBlackholeSym(const Value* val);
+    static bool isArgOfUncalledFunction(const Value* val);
+    static bool isReturn(const SVFInstruction *inst);
+    static bool isPtrInUncalledFunction (const Value*  value);
+    static const u32_t getBBSuccessorNum(const SVFBasicBlock* bb);
     static const Type* getPtrElementType(const PointerType* pty);
-    static const u32_t getBBSuccessorPos(const BasicBlock *BB, const BasicBlock *Succ);
-    static const u32_t getBBPredecessorPos(const BasicBlock *BB, const BasicBlock *Pred);
 
     static inline bool isBlkPtr(NodeID id)
     {
@@ -231,11 +225,11 @@ public:
 
     /// Get different kinds of syms
     //@{
-    SymID getValSym(const Value *val);
+    SymID getValSym(const Value* val);
 
     bool hasValSym(const Value* val);
 
-    inline SymID getObjSym(const Value *val) const
+    inline SymID getObjSym(const Value* val) const
     {
         ValueToIDMapTy::const_iterator iter = objSymMap.find(SVFUtil::getGlobalRep(val));
         assert(iter!=objSymMap.end() && "obj sym not found");
@@ -249,14 +243,14 @@ public:
         return iter->second;
     }
 
-    inline SymID getRetSym(const Function *val) const
+    inline SymID getRetSym(const SVFFunction* val) const
     {
         FunToIDMapTy::const_iterator iter =  returnSymMap.find(val);
         assert(iter!=returnSymMap.end() && "ret sym not found");
         return iter->second;
     }
 
-    inline SymID getVarargSym(const Function *val) const
+    inline SymID getVarargSym(const SVFFunction* val) const
     {
         FunToIDMapTy::const_iterator iter =  varargSymMap.find(val);
         assert(iter!=varargSymMap.end() && "vararg sym not found");
@@ -382,13 +376,13 @@ private:
     /// Type information of this object
     ObjTypeInfo* typeInfo;
     /// The unique value of this symbol/variable
-    const Value *refVal;
+    const Value* refVal;
     /// The unique id to represent this symbol
     SymID symId;
 
 public:
     /// Constructor
-    MemObj(SymID id, ObjTypeInfo* ti, const Value *val = nullptr);
+    MemObj(SymID id, ObjTypeInfo* ti, const Value* val = nullptr);
 
     /// Destructor
     virtual ~MemObj()