svf-tools 1.0.892 → 1.0.894

package/svf/include/AE/Svfexe/AbstractExecution.h

@@ -43,10 +43,6 @@ class ExeState;
 
 template<typename T> class FILOWorkList;
 
-
-
-
-
 enum class AEKind
 {
     AbstractExecution,
@@ -58,7 +54,7 @@ class AEStat : public SVFStat
 {
 public:
     void countStateSize();
-    AEStat(AbstractExecution *ae): _ae(ae)
+    AEStat(AbstractExecution* ae) : _ae(ae)
     {
         startTime = getClk(true);
     }
@@ -76,7 +72,7 @@ public:
     void reportBug();
 
 public:
-    AbstractExecution *_ae;
+    AbstractExecution* _ae;
     s32_t count{0};
     std::string memory_usage;
     std::string memUsage;
@@ -107,7 +103,6 @@ public:
         }
         return generalNumMap["ICFG_Node_Trace"];
     }
-
 };
 
 class AbstractExecution
@@ -116,12 +111,11 @@ class AbstractExecution
     friend class AEAPI;
 
 public:
-    typedef SCCDetection<PTACallGraph *> CallGraphSCC;
+    enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
+    typedef SCCDetection<PTACallGraph*> CallGraphSCC;
     /// Constructor
     AbstractExecution();
 
-    virtual void initExtAPI();
-
     virtual void runOnModule(ICFG* icfg);
 
     /// Destructor
@@ -153,7 +147,7 @@ protected:
      * @param node The ICFGNode to analyse
      * @return if this node has preceding execution state
      */
-    bool hasInEdgesES(const ICFGNode *node);
+    bool hasInEdgesES(const ICFGNode* node);
 
     /**
      * Check if execution state exist at the branch edge
@@ -175,7 +169,7 @@ protected:
      *
      * @param node ICFGNode which has a single instruction
      */
-    virtual void handleICFGNode(const ICFGNode *node);
+    virtual void handleICFGNode(const ICFGNode* node);
 
     /**
      * handle call node in ICFGNode
@@ -189,35 +183,35 @@ protected:
      *
      * @param cycle WTOCycle which has weak topo order of basic blocks and nested cycles
      */
-    virtual void handleCycle(const ICFGWTOCycle *cycle);
+    virtual void handleCycle(const ICFGWTOCycle* cycle);
 
     /**
      * handle user defined function, ext function is not included.
      *
      * @param func SVFFunction which has a series of basic blocks
      */
-    virtual void handleFunc(const SVFFunction *func);
+    virtual void handleFunc(const SVFFunction* func);
 
     /**
      * handle SVF Statement like CmpStmt, CallStmt, GepStmt, LoadStmt, StoreStmt, etc.
      *
      * @param stmt SVFStatement which is a value flow of instruction
      */
-    virtual void handleSVFStatement(const SVFStmt *stmt);
+    virtual void handleSVFStatement(const SVFStmt* stmt);
 
     /**
      * Check if this callnode is recursive call and skip it.
      *
      * @param callnode CallICFGNode which calls a recursive function
      */
-    virtual void SkipRecursiveCall(const CallICFGNode *callnode);
+    virtual void SkipRecursiveCall(const CallICFGNode* callnode);
 
     /**
     * Check if this function is recursive function and skip it.
     *
     * @param func SVFFunction is a recursive function
-    */
-    virtual void SkipRecursiveFunc(const SVFFunction *func);
+     */
+    virtual void SkipRecursiveFunc(const SVFFunction* func);
 
     /**
     * Check if this cmpStmt and succ are satisfiable to the execution state.
@@ -237,84 +231,6 @@ protected:
     */
     bool hasSwitchBranchES(const SVFVar* var, s64_t succ, IntervalExeState& es);
 
-    /// protected data members, also used in subclasses
-    SVFIR* _svfir;
-    PTACallGraph* _callgraph;
-    /// Execution State, used to store the Interval Value of every SVF variable
-    SVFIR2ItvExeState* _svfir2ExeState;
-    AEAPI* _api{nullptr};
-
-    ICFG* _icfg;
-    AEStat* _stat;
-    AEKind _kind;
-
-    Set<std::string> _bugLoc;
-    SVFBugReport _recoder;
-    std::vector<const CallICFGNode*> _callSiteStack;
-    Map<const ICFGNode *, std::string> _nodeToBugInfo;
-    AndersenWaveDiff *_ander;
-    Map<const SVFFunction*, ICFGWTO *> _funcToWTO;
-    Set<const SVFFunction*> _recursiveFuns;
-
-private:
-    // helper functions in handleCallSite
-    virtual bool isExtCall(const CallICFGNode* callNode);
-    virtual void extCallPass(const CallICFGNode* callNode);
-    virtual bool isRecursiveCall(const CallICFGNode* callNode);
-    virtual void recursiveCallPass(const CallICFGNode* callNode);
-    virtual bool isDirectCall(const CallICFGNode* callNode);
-    virtual void directCallFunPass(const CallICFGNode* callNode);
-    virtual bool isIndirectCall(const CallICFGNode* callNode);
-    virtual void indirectCallFunPass(const CallICFGNode* callNode);
-
-    // helper functions in hasInEdgesES
-    bool isFunEntry(const ICFGNode* node);
-    bool isGlobalEntry(const ICFGNode* node);
-
-    // helper functions in handleCycle
-    bool widenFixpointPass(const ICFGNode* cycle_head, IntervalExeState& pre_es);
-    bool narrowFixpointPass(const ICFGNode* cycle_head, IntervalExeState& pre_es);
-
-    // private data
-    Map<const ICFGNode*, IntervalExeState> _preES;
-    Map<const ICFGNode*, IntervalExeState> _postES;
-    std::string _moduleName;
-
-
-};
-
-class AEAPI
-{
-public:
-    enum ExtAPIType { UNCLASSIFIED, MEMCPY, MEMSET, STRCPY, STRCAT };
-    static bool classof(const AEAPI* api)
-    {
-        return api->getKind() == AEKind::AbstractExecution;
-    }
-
-    /**
-    * Constructor of AEAPI
-    *
-    * @param ae Abstract Execution or its subclass
-    * @param stat AEStat
-    */
-    AEAPI(AbstractExecution* ae, AEStat* stat): _ae(ae), _stat(stat)
-    {
-        initExtFunMap();
-        _kind = AEKind::AbstractExecution;
-    }
-
-    virtual ~AEAPI() {}
-
-    void setModule(SVFIR* svfModule)
-    {
-        _svfir = svfModule;
-    }
-
-    AEKind getKind() const
-    {
-        return _kind;
-    }
 
     /**
     * handle external function call
@@ -414,8 +330,6 @@ public:
 
     void collectCheckPoint();
     void checkPointAllSet();
-
-protected:
     // helper functions for traceMemoryAllocationSize and canSafelyAccessMemory
     void AccessMemoryViaRetNode(const CallICFGNode *callnode, SVF::FILOWorkList<const SVFValue *>& worklist, Set<const SVFValue *>& visited);
     void AccessMemoryViaCopyStmt(const CopyStmt *copy, SVF::FILOWorkList<const SVFValue *>& worklist, Set<const SVFValue *>& visited);
@@ -423,16 +337,55 @@ protected:
     void AccessMemoryViaCallArgs(const SVF::SVFArgument *arg, SVF::FILOWorkList<const SVFValue *>& worklist, Set<const SVFValue *>& visited);
 
 
-protected:
-    AbstractExecution* _ae;
-    AEStat* _stat;
+    /// protected data members, also used in subclasses
     SVFIR* _svfir;
+    PTACallGraph* _callgraph;
+    /// Execution State, used to store the Interval Value of every SVF variable
+    SVFIR2ItvExeState* _svfir2ExeState;
+    AEAPI* _api{nullptr};
+
+    ICFG* _icfg;
+    AEStat* _stat;
     AEKind _kind;
 
-    Map<std::string, std::function<void(const CallSite &)>> _func_map;
+    Set<std::string> _bugLoc;
+    SVFBugReport _recoder;
+    std::vector<const CallICFGNode*> _callSiteStack;
+    Map<const ICFGNode*, std::string> _nodeToBugInfo;
+    AndersenWaveDiff* _ander;
+    Map<const SVFFunction*, ICFGWTO*> _funcToWTO;
+    Set<const SVFFunction*> _recursiveFuns;
 
+private:
+    // helper functions in handleCallSite
+    virtual bool isExtCall(const CallICFGNode* callNode);
+    virtual void extCallPass(const CallICFGNode* callNode);
+    virtual bool isRecursiveCall(const CallICFGNode* callNode);
+    virtual void recursiveCallPass(const CallICFGNode* callNode);
+    virtual bool isDirectCall(const CallICFGNode* callNode);
+    virtual void directCallFunPass(const CallICFGNode* callNode);
+    virtual bool isIndirectCall(const CallICFGNode* callNode);
+    virtual void indirectCallFunPass(const CallICFGNode* callNode);
+
+    // helper functions in hasInEdgesES
+    bool isFunEntry(const ICFGNode* node);
+    bool isGlobalEntry(const ICFGNode* node);
+
+    // helper functions in handleCycle
+    bool widenFixpointPass(const ICFGNode* cycle_head,
+                           IntervalExeState& pre_es);
+    bool narrowFixpointPass(const ICFGNode* cycle_head,
+                            IntervalExeState& pre_es);
+
+protected:
+    // there data should be shared with subclasses
+    Map<std::string, std::function<void(const CallSite &)>> _func_map;
     Set<const CallICFGNode*> _checkpoints;
     Set<std::string> _checkpoint_names;
 
+private:
+    Map<const ICFGNode*, IntervalExeState> _preES;
+    Map<const ICFGNode*, IntervalExeState> _postES;
+    std::string _moduleName;
 };
 }

package/svf/include/AE/Svfexe/BufOverflowChecker.h

@@ -100,27 +100,28 @@ protected:
     const SVFValue* _allocVar;
 };
 
-class BufOverflowCheckerAPI: public AEAPI
+class BufOverflowChecker: public AbstractExecution
 {
 public:
-    BufOverflowCheckerAPI() = delete;
-    BufOverflowCheckerAPI(AbstractExecution * ae, AEStat * stat): AEAPI(ae, stat)
+    BufOverflowChecker() : AbstractExecution()
     {
         initExtFunMap();
-        initExtAPIBufOverflowCheckRules();
         _kind = AEKind::BufOverflowChecker;
+        initExtAPIBufOverflowCheckRules();
     }
-    static bool classof(const AEAPI* api)
+
+    static bool classof(const AbstractExecution* ae)
     {
-        return api->getKind() == AEKind::BufOverflowChecker;
+        return ae->getKind() == AEKind::BufOverflowChecker;
     }
 
+protected:
     /**
     * the map of external function to its API type
     *
     * it initialize the ext apis about buffer overflow checking
     */
-    virtual void initExtFunMap();
+    virtual void initExtFunMap() override;
 
     /**
     * the map of ext apis of buffer overflow checking rules
@@ -136,7 +137,7 @@ public:
     *
     * @param call call node whose callee is external function
     */
-    void handleExtAPI(const CallICFGNode *call) ;
+    void handleExtAPI(const CallICFGNode *call) override;
     /**
     * detect buffer overflow from strcpy like apis
     * e.g. strcpy(dst, src), if dst is shorter than src, we will throw buffer overflow
@@ -165,31 +166,6 @@ public:
      */
     bool canSafelyAccessMemory(const SVFValue *value, const IntervalValue &len, const ICFGNode *curNode);
 
-
-    Map<NodeID, const GepStmt*> _addrToGep;
-    Map<std::string, std::vector<std::pair<u32_t, u32_t>>> _extAPIBufOverflowCheckRules;
-};
-
-class BufOverflowChecker: public AbstractExecution
-{
-    friend BufOverflowCheckerAPI;
-
-public:
-    BufOverflowChecker() : AbstractExecution()
-    {
-        _kind = AEKind::BufOverflowChecker;
-    }
-
-    static bool classof(const AbstractExecution* ae)
-    {
-        return ae->getKind() == AEKind::BufOverflowChecker;
-    }
-
-    void initExtAPI() override
-    {
-        _api = new BufOverflowCheckerAPI(this, _stat);
-    }
-
 private:
     /**
     * handle SVF statement regarding buffer overflow checking
@@ -221,6 +197,9 @@ private:
     */
     void addBugToRecoder(const BufOverflowException& e, const ICFGNode* node);
 
+private:
+    Map<NodeID, const GepStmt*> _addrToGep;
+    Map<std::string, std::vector<std::pair<u32_t, u32_t>>> _extAPIBufOverflowCheckRules;
 
 };
 }