svf-lib 1.0.2319 → 1.0.2321

package/SVF-osx/Release-build/include/SVF/Util/SVFBugReport.h

@@ -0,0 +1,427 @@
+//===- SVFBugReport.h -- Base class for statistics---------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013->  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+//
+// Created by JoelYang on 2023/4/19.
+//
+
+#ifndef SVF_BUGRECODER_H
+#define SVF_BUGRECODER_H
+
+#include <vector>
+#include "SVFIR/SVFValue.h"
+#include "SVFIR/SVFVariables.h"
+#include "SVFIR/SVFStatements.h"
+#include "Graphs/ICFGNode.h"
+#include <string>
+#include <map>
+#include "Util/cJSON.h"
+#include <set>
+
+#define BRANCHFLAGMASK 0x00000010
+#define EVENTTYPEMASK 0x0000000f
+
+namespace SVF
+{
+
+/*!
+ * Bug Detector Recoder
+ */
+
+
+class SVFBugEvent
+{
+public:
+    enum EventType
+    {
+        Branch = 0x1,
+        Caller = 0x2,
+        CallSite = 0x3,
+        Loop = 0x4,
+        SourceInst = 0x5
+    };
+
+protected:
+    u32_t typeAndInfoFlag;
+    const ICFGNode *eventInst;
+
+public:
+    SVFBugEvent(u32_t typeAndInfoFlag, const ICFGNode *eventInst): typeAndInfoFlag(typeAndInfoFlag), eventInst(eventInst) { };
+    virtual ~SVFBugEvent() = default;
+
+    inline u32_t getEventType() const
+    {
+        return typeAndInfoFlag & EVENTTYPEMASK;
+    }
+    virtual const std::string getEventDescription() const;
+    virtual const std::string getFuncName() const;
+    virtual const std::string getEventLoc() const;
+};
+
+class GenericBug
+{
+public:
+    typedef std::vector<SVFBugEvent> EventStack;
+
+public:
+    enum BugType {FULLBUFOVERFLOW, PARTIALBUFOVERFLOW, NEVERFREE, PARTIALLEAK, DOUBLEFREE, FILENEVERCLOSE, FILEPARTIALCLOSE, FULLNULLPTRDEREFERENCE, PARTIALNULLPTRDEREFERENCE};
+    static const std::map<GenericBug::BugType, std::string> BugType2Str;
+
+protected:
+    BugType bugType;
+    const EventStack bugEventStack;
+
+public:
+    /// note: should be initialized with a bugEventStack
+    GenericBug(BugType bugType, const EventStack &bugEventStack):
+        bugType(bugType), bugEventStack(bugEventStack)
+    {
+        assert(bugEventStack.size() != 0 && "bugEventStack should NOT be empty!");
+    }
+    virtual ~GenericBug() = default;
+    //GenericBug(const GenericBug &) = delete;
+    /// returns bug type
+    inline BugType getBugType() const
+    {
+        return bugType;
+    }
+    /// returns bug location as json format string
+    const std::string getLoc() const;
+    /// return bug source function name
+    const std::string getFuncName() const;
+
+    inline const EventStack& getEventStack() const
+    {
+        return bugEventStack;
+    }
+
+    virtual cJSON *getBugDescription() const = 0;
+    virtual void printBugToTerminal() const = 0;
+};
+
+class BufferOverflowBug: public GenericBug
+{
+protected:
+    s64_t allocLowerBound, allocUpperBound, accessLowerBound, accessUpperBound;
+
+public:
+    BufferOverflowBug(GenericBug::BugType bugType, const EventStack &eventStack,
+                      s64_t allocLowerBound, s64_t allocUpperBound,
+                      s64_t accessLowerBound, s64_t accessUpperBound):
+        GenericBug(bugType, eventStack), allocLowerBound(allocLowerBound),
+        allocUpperBound(allocUpperBound), accessLowerBound(accessLowerBound),
+        accessUpperBound(accessUpperBound) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::PARTIALBUFOVERFLOW || bug->getBugType() == GenericBug::FULLBUFOVERFLOW;
+    }
+};
+
+class FullBufferOverflowBug: public BufferOverflowBug
+{
+public:
+    FullBufferOverflowBug(const EventStack &eventStack,
+                          s64_t allocLowerBound, s64_t allocUpperBound,
+                          s64_t accessLowerBound, s64_t accessUpperBound):
+        BufferOverflowBug(GenericBug::FULLBUFOVERFLOW, eventStack, allocLowerBound,
+                          allocUpperBound, accessLowerBound, accessUpperBound) { }
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::FULLBUFOVERFLOW;
+    }
+};
+
+class PartialBufferOverflowBug: public BufferOverflowBug
+{
+public:
+    PartialBufferOverflowBug( const EventStack &eventStack,
+                              s64_t allocLowerBound, s64_t allocUpperBound,
+                              s64_t accessLowerBound, s64_t accessUpperBound):
+        BufferOverflowBug(GenericBug::PARTIALBUFOVERFLOW, eventStack, allocLowerBound,
+                          allocUpperBound, accessLowerBound, accessUpperBound) { }
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::PARTIALBUFOVERFLOW;
+    }
+};
+
+class NeverFreeBug : public GenericBug
+{
+public:
+    NeverFreeBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::NEVERFREE, bugEventStack) {  };
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::NEVERFREE;
+    }
+};
+
+class PartialLeakBug : public GenericBug
+{
+public:
+    PartialLeakBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::PARTIALLEAK, bugEventStack) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::PARTIALLEAK;
+    }
+};
+
+class DoubleFreeBug : public GenericBug
+{
+public:
+    DoubleFreeBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::DOUBLEFREE, bugEventStack) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::DOUBLEFREE;
+    }
+};
+
+class FileNeverCloseBug : public GenericBug
+{
+public:
+    FileNeverCloseBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::FILENEVERCLOSE, bugEventStack) {  };
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::FILENEVERCLOSE;
+    }
+};
+
+class FilePartialCloseBug : public GenericBug
+{
+public:
+    FilePartialCloseBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::FILEPARTIALCLOSE, bugEventStack) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::FILEPARTIALCLOSE;
+    }
+};
+
+class FullNullPtrDereferenceBug : public GenericBug
+{
+public:
+    FullNullPtrDereferenceBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::FULLNULLPTRDEREFERENCE, bugEventStack) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::FULLNULLPTRDEREFERENCE;
+    }
+};
+
+class PartialNullPtrDereferenceBug : public GenericBug
+{
+public:
+    PartialNullPtrDereferenceBug(const EventStack &bugEventStack):
+        GenericBug(GenericBug::PARTIALNULLPTRDEREFERENCE, bugEventStack) { }
+
+    cJSON *getBugDescription() const;
+    void printBugToTerminal() const;
+
+    /// ClassOf
+    static inline bool classof(const GenericBug *bug)
+    {
+        return bug->getBugType() == GenericBug::PARTIALNULLPTRDEREFERENCE;
+    }
+};
+
+class SVFBugReport
+{
+public:
+    SVFBugReport() = default;
+    ~SVFBugReport();
+    typedef SVF::Set<const GenericBug *> BugSet;
+
+protected:
+    BugSet bugSet;    // maintain bugs
+    double time;     // time (sec)
+    std::string mem;       // string memory (KB)
+    double coverage;  // coverage (%)
+
+public:
+    // set time, mem and coverage
+    void setStat(double time, std::string mem, double coverage)
+    {
+        this->time = time;
+        this->mem = mem;
+        this->coverage = coverage;
+    }
+
+    /*
+     * function: pass bug type (i.e., GenericBug::NEVERFREE) and eventStack as parameter,
+     *      it will add the bug into bugQueue.
+     * usage: addSaberBug(GenericBug::NEVERFREE, eventStack)
+     */
+    void addSaberBug(GenericBug::BugType bugType, const GenericBug::EventStack &eventStack)
+    {
+        /// create and add the bug
+        GenericBug *newBug = nullptr;
+        switch(bugType)
+        {
+        case GenericBug::NEVERFREE:
+        {
+            newBug = new NeverFreeBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::PARTIALLEAK:
+        {
+            newBug = new PartialLeakBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::DOUBLEFREE:
+        {
+            newBug = new DoubleFreeBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::FILENEVERCLOSE:
+        {
+            newBug = new FileNeverCloseBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::FILEPARTIALCLOSE:
+        {
+            newBug = new FilePartialCloseBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        default:
+        {
+            assert(false && "saber does NOT have this bug type!");
+            break;
+        }
+        }
+
+        // when add a bug, also print it to terminal
+        newBug->printBugToTerminal();
+    }
+
+    /*
+     * function: pass bug type (i.e., GenericBug::FULLBUFOVERFLOW) and eventStack as parameter,
+     *      it will add the bug into bugQueue.
+     * usage: addAbsExecBug(GenericBug::FULLBUFOVERFLOW, eventStack, 0, 10, 11, 11)
+     */
+    void addAbsExecBug(GenericBug::BugType bugType, const GenericBug::EventStack &eventStack,
+                       s64_t allocLowerBound, s64_t allocUpperBound, s64_t accessLowerBound, s64_t accessUpperBound)
+    {
+        /// add bugs
+        GenericBug *newBug = nullptr;
+        switch(bugType)
+        {
+        case GenericBug::FULLBUFOVERFLOW:
+        {
+            newBug = new FullBufferOverflowBug(eventStack, allocLowerBound, allocUpperBound, accessLowerBound, accessUpperBound);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::PARTIALBUFOVERFLOW:
+        {
+            newBug = new PartialBufferOverflowBug(eventStack, allocLowerBound, allocUpperBound, accessLowerBound, accessUpperBound);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::FULLNULLPTRDEREFERENCE:
+        {
+            newBug = new FullNullPtrDereferenceBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        case GenericBug::PARTIALNULLPTRDEREFERENCE:
+        {
+            newBug = new PartialNullPtrDereferenceBug(eventStack);
+            bugSet.insert(newBug);
+            break;
+        }
+        default:
+        {
+            assert(false && "Abstract Execution does NOT have this bug type!");
+            break;
+        }
+        }
+
+        // when add a bug, also print it to terminal
+        //newBug->printBugToTerminal();
+    }
+
+    /*
+     * function: pass file path, open the file and dump bug report as JSON format
+     * usage: dumpToFile("/path/to/file")
+     */
+    void dumpToJsonFile(const std::string& filePath) const;
+
+    /*
+     * function: get underlying bugset
+     * usage: getBugSet()
+     */
+    const BugSet &getBugSet() const
+    {
+        return bugSet;
+    }
+
+};
+}
+
+#endif

package/SVF-osx/Release-build/include/SVF/Util/SVFLoopAndDomInfo.h

@@ -0,0 +1,169 @@
+//===- SVFLoopAndDomInfo.h -- ------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+* SVFLoopAndDomInfo.h
+*
+*  Created on: Feb 7, 2025
+*      Author: Xiao Cheng
+*
+*/
+
+#ifndef SVFLOOPANDDOMINFO_H
+#define SVFLOOPANDDOMINFO_H
+
+#include "SVFIR/SVFType.h"
+#include "Graphs/GraphPrinter.h"
+#include "Util/Casting.h"
+#include "Graphs/BasicBlockG.h"
+
+namespace SVF
+{
+class SVFLoopAndDomInfo
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+public:
+    typedef Set<const SVFBasicBlock*> BBSet;
+    typedef std::vector<const SVFBasicBlock*> BBList;
+    typedef BBList LoopBBs;
+
+private:
+    BBList reachableBBs;    ///< reachable BasicBlocks from the function entry.
+    Map<const SVFBasicBlock*,BBSet> dtBBsMap;   ///< map a BasicBlock to BasicBlocks it Dominates
+    Map<const SVFBasicBlock*,BBSet> pdtBBsMap;   ///< map a BasicBlock to BasicBlocks it PostDominates
+    Map<const SVFBasicBlock*,BBSet> dfBBsMap;    ///< map a BasicBlock to its Dominate Frontier BasicBlocks
+    Map<const SVFBasicBlock*, LoopBBs> bb2LoopMap;  ///< map a BasicBlock (if it is in a loop) to all the BasicBlocks in this loop
+    Map<const SVFBasicBlock*, u32_t> bb2PdomLevel;  ///< map a BasicBlock to its level in pdom tree, used in findNearestCommonPDominator
+    Map<const SVFBasicBlock*, const SVFBasicBlock*> bb2PIdom;  ///< map a BasicBlock to its immediate dominator in pdom tree, used in findNearestCommonPDominator
+
+public:
+    SVFLoopAndDomInfo()
+    {
+    }
+
+    virtual ~SVFLoopAndDomInfo() {}
+
+    inline const Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap() const
+    {
+        return dfBBsMap;
+    }
+
+    inline Map<const SVFBasicBlock*,BBSet>& getDomFrontierMap()
+    {
+        return dfBBsMap;
+    }
+
+    inline bool hasLoopInfo(const SVFBasicBlock* bb) const
+    {
+        return bb2LoopMap.find(bb) != bb2LoopMap.end();
+    }
+
+    const LoopBBs& getLoopInfo(const SVFBasicBlock* bb) const;
+
+    inline const SVFBasicBlock* getLoopHeader(const LoopBBs& lp) const
+    {
+        assert(!lp.empty() && "this is not a loop, empty basic block");
+        return lp.front();
+    }
+
+    inline bool loopContainsBB(const LoopBBs& lp, const SVFBasicBlock* bb) const
+    {
+        return std::find(lp.begin(), lp.end(), bb) != lp.end();
+    }
+
+    inline void addToBB2LoopMap(const SVFBasicBlock* bb, const SVFBasicBlock* loopBB)
+    {
+        bb2LoopMap[bb].push_back(loopBB);
+    }
+
+    inline const Map<const SVFBasicBlock*,BBSet>& getPostDomTreeMap() const
+    {
+        return pdtBBsMap;
+    }
+
+    inline Map<const SVFBasicBlock*,BBSet>& getPostDomTreeMap()
+    {
+        return pdtBBsMap;
+    }
+
+    inline const Map<const SVFBasicBlock*,u32_t>& getBBPDomLevel() const
+    {
+        return bb2PdomLevel;
+    }
+
+    inline Map<const SVFBasicBlock*,u32_t>& getBBPDomLevel()
+    {
+        return bb2PdomLevel;
+    }
+
+    inline const Map<const SVFBasicBlock*,const SVFBasicBlock*>& getBB2PIdom() const
+    {
+        return bb2PIdom;
+    }
+
+    inline Map<const SVFBasicBlock*,const SVFBasicBlock*>& getBB2PIdom()
+    {
+        return bb2PIdom;
+    }
+
+
+    inline Map<const SVFBasicBlock*,BBSet>& getDomTreeMap()
+    {
+        return dtBBsMap;
+    }
+
+    inline const Map<const SVFBasicBlock*,BBSet>& getDomTreeMap() const
+    {
+        return dtBBsMap;
+    }
+
+    inline bool isUnreachable(const SVFBasicBlock* bb) const
+    {
+        return std::find(reachableBBs.begin(), reachableBBs.end(), bb) ==
+               reachableBBs.end();
+    }
+
+    inline const BBList& getReachableBBs() const
+    {
+        return reachableBBs;
+    }
+
+    inline void setReachableBBs(BBList& bbs)
+    {
+        reachableBBs = bbs;
+    }
+
+    void getExitBlocksOfLoop(const SVFBasicBlock* bb, BBList& exitbbs) const;
+
+    bool isLoopHeader(const SVFBasicBlock* bb) const;
+
+    bool dominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const;
+
+    bool postDominate(const SVFBasicBlock* bbKey, const SVFBasicBlock* bbValue) const;
+
+    /// find nearest common post dominator of two basic blocks
+    const SVFBasicBlock *findNearestCommonPDominator(const SVFBasicBlock *A, const SVFBasicBlock *B) const;
+};
+}
+
+#endif //SVFLOOPANDDOMINFO_H

package/SVF-osx/Release-build/include/SVF/Util/SVFStat.h

@@ -0,0 +1,103 @@
+//===- SVFStat.h -- Base class for statistics---------------------------------//
+//
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2017>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * SVFStat.h
+ *
+ *  Created on: Sep 1, 2022
+ *      Author: Xiao Cheng
+ */
+
+#ifndef SVF_SVFSTAT_H
+#define SVF_SVFSTAT_H
+
+namespace SVF
+{
+
+
+/*!
+ * Pointer Analysis Statistics
+ */
+class SVFStat
+{
+public:
+
+    typedef OrderedMap<std::string, u32_t> NUMStatMap;
+
+    typedef OrderedMap<std::string, double> TIMEStatMap;
+
+    enum ClockType
+    {
+        Wall,
+        CPU,
+    };
+
+    SVFStat();
+
+    virtual ~SVFStat() {}
+
+    virtual inline void startClk()
+    {
+        startTime = getClk(true);
+    }
+
+    virtual inline void endClk()
+    {
+        endTime = getClk(true);
+    }
+
+    /// When mark is true, real clock is always returned. When mark is false, it is
+    /// only returned when Options::MarkedClocksOnly is not set.
+    /// Default call for getClk is unmarked, while MarkedClocksOnly is false by default.
+    static double getClk(bool mark = false);
+
+    /// SVF's general statistics are only printed once even if you run multiple anayses
+    static bool printGeneralStats;
+
+    NUMStatMap generalNumMap;
+    NUMStatMap PTNumStatMap;
+    TIMEStatMap timeStatMap;
+
+    double startTime;
+    double endTime;
+
+    virtual void performStat() = 0;
+
+    virtual void printStat(std::string str = "");
+
+    virtual void performStatPerQuery(NodeID) {}
+
+    virtual void printStatPerQuery(NodeID, const PointsTo &) {}
+
+    virtual void callgraphStat() {}
+
+    static double timeOfBuildingLLVMModule;
+    static double timeOfBuildingSymbolTable;
+    static double timeOfBuildingSVFIR;
+
+private:
+    void branchStat();
+    std::string moduleName;
+}; // End class SVFStat
+
+} // End namespace SVF
+#endif //SVF_SVFSTAT_H