svf-lib 1.0.1289 → 1.0.1291

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

@@ -9,6 +9,7 @@
 #define MTARESULTVALIDATOR_H_
 
 #include "MTA/MHP.h"
+#include "SVF-LLVM/LLVMUtil.h"
 
 /*!
  * Validate the result of context-sensitive analysis, including context-sensitive
@@ -52,9 +53,9 @@ protected:
     std::vector<std::string> split(const std::string &s, char delim);
 
     // Get special arguments of given call sites
-    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);
+    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);
 
     /*
      * Get the previous LoadInst or StoreInst from Instruction "I" in the
@@ -274,7 +275,7 @@ protected:
     void collectValidationTargets()
     {
         // Collect call sites of all RC_ACCESS function calls.
-        std::vector<CallSite> csInsts;
+        std::vector<const CallBase*> csInsts;
         const Function* F = nullptr;
         for (Module &M : LLVMModuleSet::getLLVMModuleSet()->getLLVMModules())
         {
@@ -295,9 +296,9 @@ protected:
         {
             const Use *u = &*it;
             const Value *user = u->getUser();
-            if(SVFUtil::isCallSite(user))
+            if(LLVMUtil::isCallSite(user))
             {
-                CallSite csInst = SVFUtil::getLLVMCallSite(user);
+                const CallBase* csInst = LLVMUtil::getLLVMCallSite(user);
                 csInsts.push_back(csInst);
             }
         }
@@ -309,12 +310,12 @@ protected:
         // Generate access pairs.
         for (int i = 0, e = csInsts.size(); i != e;)
         {
-            CallSite CI1 = csInsts[i++];
-            CallSite CI2 = csInsts[i++];
-            const ConstantInt* C = SVFUtil::dyn_cast<ConstantInt>(CI1.getArgOperand(1));
+            const CallBase* CI1 = csInsts[i++];
+            const CallBase* CI2 = csInsts[i++];
+            const ConstantInt* C = SVFUtil::dyn_cast<ConstantInt>(CI1->getArgOperand(1));
             assert(C);
-            const Instruction* I1 = getPreviousMemoryAccessInst(CI1.getInstruction()->getLLVMInstruction());
-            const Instruction* I2 = getPreviousMemoryAccessInst(CI2.getInstruction()->getLLVMInstruction());
+            const Instruction* I1 = getPreviousMemoryAccessInst(CI1);
+            const Instruction* I2 = getPreviousMemoryAccessInst(CI2);
             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));
@@ -339,8 +340,8 @@ protected:
             bool racy = mayHaveDataRace(I1, I2);
 
             SVFUtil::outs() << "For the memory access pair at ("
-                            << SVFUtil::getSourceLoc(I1) << ", "
-                            << SVFUtil::getSourceLoc(I2) << ")\n";
+                            << LLVMModuleSet::getLLVMModuleSet()->getSVFValue(I1)->getSourceLoc() << ", "
+                            << LLVMModuleSet::getLLVMModuleSet()->getSVFValue(I2)->getSourceLoc() << ")\n";
             if (selectedValidationScenarios & RC_ALIASES)
             {
                 SVFUtil::outs() << "\t"
@@ -395,10 +396,10 @@ 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(CallSite CI1, CallSite CI2)
+    static bool compare(const CallBase* CI1, const CallBase* CI2)
     {
-        const Value *V1 = CI1.getArgOperand(0);
-        const Value *V2 = CI2.getArgOperand(0);
+        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);

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

@@ -60,7 +60,7 @@ public:
     /// Statistics for MHP statement pairs
     void performMHPPairStat(MHP* mhp, LockAnalysis* lsa);
     /// Statistics for annotation
-    void performAnnotationStat(MTAAnnotator* anno);
+    //void performAnnotationStat(MTAAnnotator* anno);
 
     double TCTTime;
     double MHPTime;

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

@@ -34,7 +34,6 @@
 #include "Util/SVFUtil.h"
 #include "Graphs/ThreadCallGraph.h"
 #include "Util/CxtStmt.h"
-#include "SVF-FE/DataFlowUtil.h"
 #include <set>
 #include <vector>
 
@@ -137,6 +136,7 @@ class TCT: public GenericThreadCreateTreeTy
 {
 
 public:
+    typedef SVFLoopAndDomInfo::LoopBBs LoopBBs;
     typedef TCTEdge::ThreadCreateEdgeSet ThreadCreateEdgeSet;
     typedef ThreadCreateEdgeSet::iterator TCTNodeIter;
     typedef Set<const SVFFunction*> FunSet;
@@ -146,7 +146,7 @@ public:
     typedef Map<CxtThread,TCTNode*> CxtThreadToNodeMap;
     typedef Map<CxtThread,CallStrCxt> CxtThreadToForkCxt;
     typedef Map<CxtThread,const SVFFunction*> CxtThreadToFun;
-    typedef Map<const SVFInstruction*, const Loop*> InstToLoopMap;
+    typedef Map<const SVFInstruction*, LoopBBs> InstToLoopMap;
     typedef FIFOWorkList<CxtThreadProc> CxtThreadProcVec;
     typedef Set<CxtThreadProc> CxtThreadProcSet;
     typedef SCCDetection<PTACallGraph*> ThreadCallGraphSCC;
@@ -355,29 +355,37 @@ public:
     }
 
     /// Get loop for join site
-    inline const Loop* getJoinLoop(const SVFInstruction* join)
+    inline LoopBBs& getJoinLoop(const SVFInstruction* join)
+    {
+        assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
+        InstToLoopMap::iterator it = joinSiteToLoopMap.find(join);
+        assert(it!=joinSiteToLoopMap.end() && "loop not found");
+        return it->second;
+    }
+
+    inline bool hasJoinLoop(const SVFInstruction* join) const
     {
         assert(tcg->getThreadAPI()->isTDJoin(join) && "not a join site");
         InstToLoopMap::const_iterator it = joinSiteToLoopMap.find(join);
-        if(it!=joinSiteToLoopMap.end())
-            return it->second;
-        return nullptr;
+        return it!=joinSiteToLoopMap.end();
+    }
+
+    bool hasLoop(const SVFBasicBlock* bb) const
+    {
+        const SVFFunction* fun = bb->getParent();
+        return fun->hasLoopInfo(bb);
+    }
+    bool hasLoop(const SVFInstruction* inst) const
+    {
+        return hasLoop(inst->getParent());
     }
     /// Return true if a join instruction must be executed inside a loop
-    bool isJoinMustExecutedInLoop(const Loop* lp,const SVFInstruction* join);
+    bool isJoinMustExecutedInLoop(const LoopBBs& lp,const SVFInstruction* join);
     /// Get loop for an instruction
-    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);
+    const LoopBBs& getLoop(const SVFInstruction* inst);
     /// Get loop for fork/join site
-    const Loop* getLoop(const SVFBasicBlock* bb);
-    /// Get SE for function
-    ScalarEvolution* getSE(const SVFInstruction* inst);
+    const LoopBBs& getLoop(const SVFBasicBlock* bb);
 
-    /// Get the next instructions following control flow
-    void getNextInsts(const SVFInstruction* inst, InstVec& instSet);
     /// Push calling context
     void pushCxt(CallStrCxt& cxt, const SVFInstruction* call, const SVFFunction* callee);
     /// Match context
@@ -558,7 +566,6 @@ private:
     CxtThreadToNodeMap ctpToNodeMap; /// Map a ctp to its graph node
     CxtThreadToForkCxt ctToForkCxtMap; /// Map a CxtThread to the context at its spawning site (fork site).
     CxtThreadToFun ctToRoutineFunMap; /// Map a CxtThread to its start routine function.
-    PTACFInfoBuilder loopInfoBuilder; ///< LoopInfo
     InstToLoopMap joinSiteToLoopMap; ///< map an inloop join to its loop class
     InstSet inRecurJoinSites;	///< Fork or Join sites in recursions
 };

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

@@ -53,7 +53,7 @@
 #ifndef ABSTRACT_POINTSTO_H_
 #define ABSTRACT_POINTSTO_H_
 
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 
 namespace SVF
 {

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

@@ -32,6 +32,7 @@
 
 #include "Util/SVFUtil.h"
 #include "MemoryModel/PointsTo.h"
+#include <sstream>
 
 namespace SVF
 {
@@ -108,7 +109,7 @@ public:
     inline std::string toString() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "<" << m_id << " " << m_cond.toString() << "> ";
         return rawstr.str();
     }
@@ -273,7 +274,7 @@ public:
     inline std::string toString() const
     {
         std::string str;
-        raw_string_ostream rawstr(str);
+        std::stringstream rawstr(str);
         rawstr << "{ ";
         for (const_iterator i = elements.begin(); i != elements.end(); ++i)
         {

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

@@ -34,7 +34,7 @@
 #define LOCATIONSET_H_
 
 
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 
 namespace SVF
 {
@@ -54,7 +54,7 @@ public:
         NonOverlap, Overlap, Subset, Superset, Same
     };
 
-    typedef std::vector<std::pair<const Value*, const Type*> > OffsetValueVec;
+    typedef std::vector<std::pair<const SVFValue*, const SVFType*> > OffsetValueVec;
 
     /// Constructor
     LocationSet(s32_t o = 0) : fldIdx(o)
@@ -105,9 +105,9 @@ public:
     s32_t accumulateConstantOffset() const;
 
     /// Return element number of a type.
-    u32_t getElementNum(const Type* type) const;
+    u32_t getElementNum(const SVFType* type) const;
 
-    bool addOffsetValue(const Value* offsetValue, const Type* type);
+    bool addOffsetValue(const SVFValue* offsetValue, const SVFType* type);
 
     /// Return TRUE if this is a constant location set.
     bool isConstantOffset() const;

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

@@ -39,7 +39,7 @@
 #include<fstream>
 
 #include "MemoryModel/AbstractPointsToDS.h"
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 #include "Util/SVFUtil.h"
 
 namespace SVF

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

@@ -18,7 +18,7 @@
 #include <iostream>
 #include <vector>
 
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 
 namespace SVF
 {

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

@@ -33,12 +33,13 @@
 #include <unistd.h>
 #include <signal.h>
 
-#include "MemoryModel/SVFIR.h"
+#include "SVFIR/SVFIR.h"
 #include "MemoryModel/ConditionalPT.h"
 #include "MemoryModel/AbstractPointsToDS.h"
 #include "MemoryModel/MutablePointsToDS.h"
 #include "MemoryModel/PersistentPointsToDS.h"
 #include "Graphs/PTACallGraph.h"
+#include "Graphs/CHG.h"
 #include "Util/SCC.h"
 #include "MemoryModel/PointsTo.h"
 
@@ -104,7 +105,7 @@ public:
     typedef Set<const SVFFunction*> FunctionSet;
     typedef OrderedMap<const CallICFGNode*, FunctionSet> CallEdgeMap;
     typedef SCCDetection<PTACallGraph*> CallGraphSCC;
-    typedef Set<const GlobalValue*> VTableSet;
+    typedef Set<const SVFGlobalValue*> VTableSet;
     typedef Set<const SVFFunction*> VFunSet;
     //@}
 
@@ -235,8 +236,8 @@ public:
     virtual void computeDDAPts(NodeID) {}
 
     /// Interface exposed to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const Value* V1,
-                              const Value* V2) = 0;
+    virtual AliasResult alias(const SVFValue* V1,
+                              const SVFValue* V2) = 0;
 
     /// Interface exposed to users of our pointer analysis, given PAGNodeID
     virtual AliasResult alias(NodeID node1, NodeID node2) = 0;

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

@@ -218,8 +218,8 @@ private:
 
 public:
     /// Interface expose to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const Value* V1,
-                              const Value* V2);
+    virtual AliasResult alias(const SVFValue* V1,
+                              const SVFValue* V2);
 
     /// Interface expose to users of our pointer analysis, given PAGNodeID
     virtual AliasResult alias(NodeID node1, NodeID node2);
@@ -504,7 +504,7 @@ public:
     }
 
     /// Interface expose to users of our pointer analysis, given Value infos
-    virtual inline AliasResult alias(const Value* V1, const Value* V2)
+    virtual inline AliasResult alias(const SVFValue* V1, const SVFValue* V2)
     {
         return  alias(pag->getValueNode(V1),pag->getValueNode(V2));
     }
@@ -573,7 +573,7 @@ public:
                 }
                 else if (!SVFUtil::isa<DummyValVar>(node))
                 {
-                    SVFUtil::outs() << "##<" << node->getValue()->getName().str() << "> ";
+                    SVFUtil::outs() << "##<" << node->getValue()->getName() << "> ";
                     //SVFUtil::outs() << "Source Loc: " << SVFUtil::getSourceLoc(node->getValue());
                 }
 

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

@@ -14,7 +14,7 @@
 
 #include <vector>
 
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 #include "Util/BitVector.h"
 #include "Util/CoreBitVector.h"
 #include "Util/SparseBitVector.h"

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

@@ -30,7 +30,7 @@
 #ifndef SVF_SVFLOOP_H
 #define SVF_SVFLOOP_H
 
-#include "Util/SVFBasicTypes.h"
+#include "SVFIR/SVFType.h"
 
 namespace SVF
 {

package/SVF-linux/include/SABER/DoubleFreeChecker.h

@@ -54,10 +54,10 @@ public:
     }
 
     /// We start from here
-    virtual bool runOnModule(SVFModule* module) override
+    virtual bool runOnModule(SVFIR* pag) override
     {
         /// start analysis
-        analyze(module);
+        analyze(pag->getModule());
         return false;
     }
 

package/SVF-linux/include/SABER/FileChecker.h

@@ -55,10 +55,10 @@ public:
     }
 
     /// We start from here
-    virtual bool runOnModule(SVFModule* module)
+    virtual bool runOnModule(SVFIR* pag)
     {
         /// start analysis
-        analyze(module);
+        analyze(pag->getModule());
         return false;
     }
 

package/SVF-linux/include/SABER/LeakChecker.h

@@ -65,10 +65,10 @@ public:
     }
 
     /// We start from here
-    virtual bool runOnModule(SVFModule* module)
+    virtual bool runOnModule(SVFIR* pag)
     {
         /// start analysis
-        analyze(module);
+        analyze(pag->getModule());
         return false;
     }
 

package/SVF-linux/include/SABER/ProgSlice.h

@@ -203,9 +203,6 @@ public:
     std::string evalFinalCond() const;
     //@}
 
-    /// Annotate program according to final condition
-    void annotatePaths();
-
 protected:
     inline const SVFG* getSVFG() const
     {

package/SVF-linux/include/SABER/SaberCondAllocator.h

@@ -30,9 +30,8 @@
 #ifndef PATHALLOCATOR_H_
 #define PATHALLOCATOR_H_
 
-#include "Util/SVFModule.h"
-#include "SVF-FE/DataFlowUtil.h"
-#include "SVF-FE/BasicTypes.h"
+#include "SVFIR/SVFModule.h"
+#include "SVFIR/SVFValue.h"
 #include "Util/WorkList.h"
 #include "Graphs/SVFG.h"
 #include "Util/Z3Expr.h"
@@ -272,15 +271,15 @@ private:
     /// Evaluate test null/not null like expressions
     //@{
     /// Return true if the predicate of this compare instruction is equal
-    bool isEQCmp(const CmpInst* cmp) const;
+    bool isEQCmp(const CmpStmt* cmp) const;
     /// Return true if the predicate of this compare instruction is not equal
-    bool isNECmp(const CmpInst* cmp) const;
+    bool isNECmp(const CmpStmt* cmp) const;
     /// Return true if this is a test null expression
-    bool isTestNullExpr(const Value* test) const;
+    bool isTestNullExpr(const SVFValue* test) const;
     /// Return true if this is a test not null expression
-    bool isTestNotNullExpr(const Value* test) const;
+    bool isTestNotNullExpr(const SVFValue* test) const;
     /// Return true if two values on the predicate are what we want
-    bool isTestContainsNullAndTheValue(const CmpInst* cmp) const;
+    bool isTestContainsNullAndTheValue(const CmpStmt* cmp) const;
     //@}
 
     /// Release memory
@@ -293,7 +292,6 @@ private:
     void extractSubConds(const Condition &condition, NodeBS &support) const;
 
 
-    PTACFInfoBuilder cfInfoBuilder;		    ///< map a function to its loop info
     FunToExitBBsMap funToExitBBsMap;		///< map a function to all its basic blocks calling program exit
     BBToCondMap bbToCondMap;				///< map a basic block to its path condition starting from root
     const SVFGNode* curEvalSVFGNode{};			///< current llvm value to evaluate branch condition when computing guards

package/SVF-linux/include/SABER/SaberSVFGBuilder.h

@@ -31,7 +31,7 @@
 #define SABERSVFGBUILDER_H_
 
 #include "MSSA/SVFGBuilder.h"
-#include "Util/BasicTypes.h"
+#include "SVFIR/SVFValue.h"
 #include "Util/WorkList.h"
 
 namespace SVF