svf-lib 1.0.2211 → 1.0.2213

package/SVF-linux/Release-build/include/Util/CDGBuilder.h

@@ -67,7 +67,7 @@ private:
 
     /// extract basic block edges to be processed
     static void
-    extractBBS(const SVFFunction *func,
+    extractBBS(const FunObjVar *func,
                Map<const SVFBasicBlock *, std::vector<const SVFBasicBlock *>> &res);
 
     /// extract nodes between two nodes in pdom tree

package/SVF-linux/Release-build/include/Util/CallGraphBuilder.h

@@ -47,7 +47,7 @@ public:
     CallGraphBuilder()=default;
 
     /// Buidl SVFIR callgraoh
-    CallGraph* buildSVFIRCallGraph(SVFModule* svfModule);
+    CallGraph* buildSVFIRCallGraph(const std::vector<const FunObjVar*>& funset);
 
     /// Buidl PTA callgraoh
     CallGraph* buildPTACallGraph();

package/SVF-linux/Release-build/include/Util/CxtStmt.h

@@ -310,7 +310,7 @@ class CxtProc
 {
 public:
     /// Constructor
-    CxtProc(const CallStrCxt& c, const SVFFunction* f) :
+    CxtProc(const CallStrCxt& c, const FunObjVar* f) :
         cxt(c), fun(f)
     {
     }
@@ -324,7 +324,7 @@ public:
     {
     }
     /// Return current procedure
-    inline const SVFFunction* getProc() const
+    inline const FunObjVar* getProc() const
     {
         return fun;
     }
@@ -383,7 +383,7 @@ public:
 
 protected:
     CallStrCxt cxt;
-    const SVFFunction* fun;
+    const FunObjVar* fun;
 };
 
 
@@ -397,7 +397,7 @@ class CxtThreadProc : public CxtProc
 {
 public:
     /// Constructor
-    CxtThreadProc(NodeID t, const CallStrCxt& c, const SVFFunction* f) :CxtProc(c,f),tid(t)
+    CxtThreadProc(NodeID t, const CallStrCxt& c, const FunObjVar* f) :CxtProc(c,f),tid(t)
     {
     }
     /// Copy constructor
@@ -494,8 +494,8 @@ template <> struct std::hash<SVF::CxtProc>
 {
     size_t operator()(const SVF::CxtProc& cs) const
     {
-        std::hash<SVF::SVFFunction*> h;
-        SVF::SVFFunction* fun = const_cast<SVF::SVFFunction*> (cs.getProc());
+        std::hash<SVF::FunObjVar*> h;
+        SVF::FunObjVar* fun = const_cast<SVF::FunObjVar*> (cs.getProc());
         return h(fun);
     }
 };

package/SVF-linux/Release-build/include/Util/ExtAPI.h

@@ -41,15 +41,19 @@
 namespace SVF
 {
 
+class FunObjVar;
+
 class ExtAPI
 {
     friend class LLVMModuleSet;
+    friend class SVFIRBuilder;
+
 private:
 
     static ExtAPI *extOp;
 
     // Map SVFFunction to its annotations
-    Map<const SVFFunction*, std::vector<std::string>> func2Annotations;
+    Map<const FunObjVar*, std::vector<std::string>> funObjVar2Annotations;
 
     // extapi.bc file path
     static std::string extBcPath;
@@ -69,44 +73,44 @@ public:
     std::string getExtBcPath();
 
     // Get the annotation of (F)
-    std::string getExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+    std::string getExtFuncAnnotation(const FunObjVar* fun, const std::string&funcAnnotation);
 
-    const std::vector<std::string>& getExtFuncAnnotations(const SVFFunction* fun);
+    const std::vector<std::string>& getExtFuncAnnotations(const FunObjVar*fun);
 
     // Does (F) have some annotation?
-    bool hasExtFuncAnnotation(const SVFFunction* fun, const std::string& funcAnnotation);
+    bool hasExtFuncAnnotation(const FunObjVar* fun, const std::string&funcAnnotation);
+
+public:
 
     // Does (F) have a static var X (unavailable to us) that its return points to?
-    bool has_static(const SVFFunction *F);
+    bool has_static(const FunObjVar *F);
 
     // Does (F) have a memcpy_like operation?
-    bool is_memcpy(const SVFFunction *F);
+    bool is_memcpy(const FunObjVar *F);
 
     // Does (F) have a memset_like operation?
-    bool is_memset(const SVFFunction *F);
+    bool is_memset(const FunObjVar *F);
 
     // Does (F) allocate a new object and return it?
-    bool is_alloc(const SVFFunction *F);
+    bool is_alloc(const FunObjVar *F);
 
     // Does (F) allocate a new object and assign it to one of its arguments?
-    bool is_arg_alloc(const SVFFunction *F);
+    bool is_arg_alloc(const FunObjVar *F);
 
     // Does (F) allocate a new stack object and return it?
-    bool is_alloc_stack_ret(const SVFFunction *F);
+    bool is_alloc_stack_ret(const FunObjVar *F);
 
     // Get the position of argument which holds the new object
-    s32_t get_alloc_arg_pos(const SVFFunction *F);
+    s32_t get_alloc_arg_pos(const FunObjVar *F);
 
     // Does (F) reallocate a new object?
-    bool is_realloc(const SVFFunction *F);
+    bool is_realloc(const FunObjVar *F);
 
-    // Should (F) be considered "external" (either not defined in the program
-    //   or a user-defined version of a known alloc or no-op)?
-    bool is_ext(const SVFFunction *F);
+    bool is_ext(const FunObjVar* funObjVar);
 
 private:
     // Set the annotation of (F)
-    void setExtFuncAnnotations(const SVFFunction* fun, const std::vector<std::string>& funcAnnotations);
+    void setExtFuncAnnotations(const FunObjVar* fun, const std::vector<std::string>&funcAnnotations);
 };
 } // End namespace SVF
 

package/SVF-linux/Release-build/include/Util/SVFUtil.h

@@ -187,7 +187,7 @@ inline bool isNonInstricCallSite(const ICFGNode* inst)
 /// Match arguments for callsite at caller and callee
 /// if the arg size does not match then we do not need to connect this parameter
 /// unless the callee is a variadic function (the first parameter of variadic function is its parameter number)
-bool matchArgs(const CallICFGNode* cs, const SVFFunction* callee);
+bool matchArgs(const CallICFGNode* cs, const FunObjVar* callee);
 
 
 /// Split into two substrings around the first occurrence of a separator string.
@@ -266,46 +266,37 @@ void stopAnalysisLimitTimer(bool limitTimerSet);
 /// Return true if the call is an external call (external library in function summary table)
 /// If the library function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
 //@{
-inline bool isExtCall(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_ext(fun);
-}
 
-inline bool isMemcpyExtFun(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_memcpy(fun);
-}
+bool isExtCall(const FunObjVar* fun);
 
-inline bool isMemsetExtFun(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_memset(fun);
-}
 
 /// Return true if the call is a heap allocator/reallocator
 //@{
 /// note that these two functions are not suppose to be used externally
-inline bool isHeapAllocExtFunViaRet(const SVFFunction* fun)
+
+inline bool isHeapAllocExtFunViaRet(const FunObjVar* fun)
 {
     return fun && (ExtAPI::getExtAPI()->is_alloc(fun)
                    || ExtAPI::getExtAPI()->is_realloc(fun));
 }
 
-inline bool isHeapAllocExtFunViaArg(const SVFFunction* fun)
+inline bool isHeapAllocExtFunViaArg(const FunObjVar* fun)
 {
     return fun && ExtAPI::getExtAPI()->is_arg_alloc(fun);
 }
 
 /// Get the position of argument that holds an allocated heap object.
 //@{
-inline u32_t getHeapAllocHoldingArgPosition(const SVFFunction* fun)
+
+inline u32_t getHeapAllocHoldingArgPosition(const FunObjVar* fun)
 {
     return ExtAPI::getExtAPI()->get_alloc_arg_pos(fun);
 }
-
 /// Return true if the call is a heap reallocator
 //@{
 /// note that this function is not suppose to be used externally
-inline bool isReallocExtFun(const SVFFunction* fun)
+
+inline bool isReallocExtFun(const FunObjVar* fun)
 {
     return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
 }
@@ -313,25 +304,20 @@ inline bool isReallocExtFun(const SVFFunction* fun)
 /// Program entry function e.g. main
 //@{
 /// Return true if this is a program entry function (e.g. main)
-inline bool isProgEntryFunction(const SVFFunction* fun)
-{
-    return fun && fun->getName() == "main";
-}
+
+bool isProgEntryFunction(const FunObjVar*);
 
 /// Get program entry function from function name.
-const SVFFunction* getProgFunction(const std::string& funName);
+const FunObjVar* getProgFunction(const std::string& funName);
 
 /// Get program entry function.
-const SVFFunction* getProgEntryFunction();
+const FunObjVar*getProgEntryFunction();
+
 
 /// Return true if this is a program exit function call
 //@{
-inline bool isProgExitFunction (const SVFFunction * fun)
-{
-    return fun && (fun->getName() == "exit" ||
-                   fun->getName() == "__assert_rtn" ||
-                   fun->getName() == "__assert_fail" );
-}
+bool isProgExitFunction(const FunObjVar *fun);
+
 
 
 bool isArgOfUncalledFunction(const SVFVar* svfvar);

package/SVF-linux/Release-build/include/Util/ThreadAPI.h

@@ -91,16 +91,7 @@ private:
     static ThreadAPI* tdAPI;
 
     /// Get the function type if it is a threadAPI function
-    inline TD_TYPE getType(const SVFFunction* F) const
-    {
-        if(F)
-        {
-            TDAPIMap::const_iterator it= tdAPIMap.find(F->getName());
-            if(it != tdAPIMap.end())
-                return it->second;
-        }
-        return TD_DUMMY;
-    }
+    TD_TYPE getType(const FunObjVar* F) const;
 
 public:
     /// Return a static reference
@@ -136,7 +127,7 @@ public:
     const ValVar* getActualParmAtForkSite(const CallICFGNode *inst) const;
 
     /// Return the formal parm of forked function (the first arg in pthread)
-    const SVFVar* getFormalParmOfForkedFun(const SVFFunction* F) const;
+    const SVFVar* getFormalParmOfForkedFun(const FunObjVar* F) const;
     //@}
 
 

package/SVF-linux/Release-build/include/WPA/Andersen.h

@@ -93,11 +93,11 @@ public:
     virtual bool updateThreadCallGraph(const CallSiteToFunPtrMap&, NodePairSet&);
 
     /// Connect formal and actual parameters for indirect forksites
-    virtual void connectCaller2ForkedFunParams(const CallICFGNode* cs, const SVFFunction* F,
+    virtual void connectCaller2ForkedFunParams(const CallICFGNode* cs, const FunObjVar* F,
             NodePairSet& cpySrcNodes);
 
     /// Connect formal and actual parameters for indirect callsites
-    virtual void connectCaller2CalleeParams(const CallICFGNode* cs, const SVFFunction* F,
+    virtual void connectCaller2CalleeParams(const CallICFGNode* cs, const FunObjVar* F,
                                             NodePairSet& cpySrcNodes);
 
     /// Methods for support type inquiry through isa, cast, and dyn_cast:

package/SVF-osx/Release-build/include/DDA/DDAClient.h

@@ -48,11 +48,11 @@ namespace SVF
 class DDAClient
 {
 public:
-    DDAClient(SVFModule* mod) : pag(nullptr), module(mod), curPtr(0), solveAll(true) {}
+    DDAClient() : pag(nullptr), curPtr(0), solveAll(true) {}
 
     virtual ~DDAClient() {}
 
-    virtual inline void initialise(SVFModule*) {}
+    virtual inline void initialise() {}
 
     /// Collect candidate pointers for query.
     virtual inline OrderedNodeSet& collectCandidateQueries(SVFIR* p)
@@ -91,16 +91,12 @@ public:
         userInput.insert(ptr);
         solveAll = false;
     }
-    /// Get LLVM module
-    inline SVFModule* getModule() const
-    {
-        return module;
-    }
+
     virtual void answerQueries(PointerAnalysis* pta);
 
     virtual inline void performStat(PointerAnalysis*) {}
 
-    virtual inline void collectWPANum(SVFModule*) {}
+    virtual inline void collectWPANum() {}
 protected:
     void addCandidate(NodeID id)
     {
@@ -109,7 +105,6 @@ protected:
     }
 
     SVFIR*   pag;					///< SVFIR graph used by current DDA analysis
-    SVFModule* module;		///< LLVM module
     NodeID curPtr;				///< current pointer being queried
     OrderedNodeSet candidateQueries;	///< store all candidate pointers to be queried
 
@@ -128,7 +123,7 @@ private:
     typedef OrderedMap<NodeID,const CallICFGNode*> VTablePtrToCallSiteMap;
     VTablePtrToCallSiteMap vtableToCallSiteMap;
 public:
-    FunptrDDAClient(SVFModule* module) : DDAClient(module) {}
+    FunptrDDAClient() : DDAClient() {}
     ~FunptrDDAClient() {}
 
     /// Only collect function pointers as query candidates.
@@ -147,7 +142,7 @@ class AliasDDAClient : public DDAClient
 public:
     typedef OrderedSet<const PAGNode*> PAGNodeSet;
 
-    AliasDDAClient(SVFModule* module) : DDAClient(module) {}
+    AliasDDAClient() : DDAClient() {}
     ~AliasDDAClient() {}
 
     /// Only collect function pointers as query candidates.

package/SVF-osx/Release-build/include/DDA/DDAPass.h

@@ -69,7 +69,7 @@ public:
     virtual void runOnModule(SVFIR* module);
 
     /// Select a client
-    virtual void selectClient(SVFModule* module);
+    virtual void selectClient();
 
     /// Pass name
     virtual inline std::string getPassName() const

package/SVF-osx/Release-build/include/Graphs/CHG.h

@@ -33,7 +33,7 @@
 #ifndef CHA_H_
 #define CHA_H_
 
-#include "SVFIR/SVFModule.h"
+#include "Util/ThreadAPI.h"
 #include "Graphs/GenericGraph.h"
 #include "Util/WorkList.h"
 
@@ -252,7 +252,7 @@ public:
         DESTRUCTOR = 0x2 // connect node based on destructor
     } RELATIONTYPE;
 
-    CHGraph(SVFModule* svfModule): svfMod(svfModule), classNum(0), vfID(0), buildingCHGTime(0)
+    CHGraph(): classNum(0), vfID(0), buildingCHGTime(0)
     {
         this->kind = Standard;
     }
@@ -318,7 +318,6 @@ public:
 
 
 private:
-    SVFModule* svfMod;
     u32_t classNum;
     u32_t vfID;
     double buildingCHGTime;