svf-lib 1.0.2319 → 1.0.2321

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

@@ -0,0 +1,117 @@
+//===- ExtAPI.h -- External functions -----------------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ExtAPI.h
+ *
+ *  Created on: July 1, 2022
+ *      Author: Shuangxiang Kan
+ */
+
+#ifndef __ExtAPI_H
+#define __ExtAPI_H
+
+#include "SVFIR/SVFValue.h"
+#include <Util/config.h>
+#include <string>
+#include <vector>
+#include <map>
+
+/// For a more detailed explanation of how External APIs are handled in SVF, please refer to the SVF Wiki: https://github.com/SVF-tools/SVF/wiki/Handling-External-APIs-with-extapi.c
+
+namespace SVF
+{
+
+class FunObjVar;
+
+class ExtAPI
+{
+    friend class LLVMModuleSet;
+    friend class SVFIRBuilder;
+
+private:
+
+    static ExtAPI *extOp;
+
+    // Map SVFFunction to its annotations
+    Map<const FunObjVar*, std::vector<std::string>> funObjVar2Annotations;
+
+    // extapi.bc file path
+    static std::string extBcPath;
+
+    ExtAPI() = default;
+
+public:
+
+    static ExtAPI *getExtAPI();
+
+    static void destory();
+
+    // Set extapi.bc file path
+    static bool setExtBcPath(const std::string& path);
+
+    // Get extapi.bc file path
+    std::string getExtBcPath();
+
+    // Get the annotation of (F)
+    std::string getExtFuncAnnotation(const FunObjVar* fun, const std::string&funcAnnotation);
+
+    const std::vector<std::string>& getExtFuncAnnotations(const FunObjVar*fun);
+
+    // Does (F) have some annotation?
+    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 FunObjVar *F);
+
+    // Does (F) have a memcpy_like operation?
+    bool is_memcpy(const FunObjVar *F);
+
+    // Does (F) have a memset_like operation?
+    bool is_memset(const FunObjVar *F);
+
+    // Does (F) allocate a new object and return it?
+    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 FunObjVar *F);
+
+    // Does (F) allocate a new stack object and return it?
+    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 FunObjVar *F);
+
+    // Does (F) reallocate a new object?
+    bool is_realloc(const FunObjVar *F);
+
+    bool is_ext(const FunObjVar* funObjVar);
+
+private:
+    // Set the annotation of (F)
+    void setExtFuncAnnotations(const FunObjVar* fun, const std::vector<std::string>&funcAnnotations);
+};
+} // End namespace SVF
+
+#endif

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

@@ -0,0 +1,127 @@
+//===- GeneralType.h -- Primitive types used in SVF--------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GeneralType.h
+ *
+ *  Created on: Feb 8, 2024
+ *      Author: Jiawei Wang
+ */
+
+#pragma once
+#include <cstdint>
+#include <deque>
+#include <iostream>
+#include <list>
+#include <map>
+#include <set>
+#include <stack>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <memory>
+#include "Util/SparseBitVector.h"
+
+namespace SVF
+{
+typedef std::ostream OutStream;
+typedef unsigned u32_t;
+typedef signed s32_t;
+typedef unsigned long long u64_t;
+typedef signed long long s64_t;
+typedef unsigned char u8_t;
+typedef signed char s8_t;
+typedef unsigned short u16_t;
+typedef signed short s16_t;
+
+typedef u32_t NodeID;
+typedef u32_t EdgeID;
+typedef unsigned CallSiteID;
+typedef unsigned ThreadID;
+typedef s64_t APOffset;
+
+typedef SparseBitVector<> NodeBS;
+typedef unsigned PointsToID;
+
+/// provide extra hash function for std::pair handling
+template <class T> struct Hash;
+
+template <class S, class T> struct Hash<std::pair<S, T>>
+{
+    // Pairing function from: http://szudzik.com/ElegantPairing.pdf
+    static size_t szudzik(size_t a, size_t b)
+    {
+        return a > b ? b * b + a : a * a + a + b;
+    }
+
+    size_t operator()(const std::pair<S, T>& t) const
+    {
+        Hash<decltype(t.first)> first;
+        Hash<decltype(t.second)> second;
+        return szudzik(first(t.first), second(t.second));
+    }
+};
+
+template <class T> struct Hash
+{
+    size_t operator()(const T& t) const
+    {
+        std::hash<T> h;
+        return h(t);
+    }
+};
+
+template <typename Key, typename Hash = Hash<Key>,
+          typename KeyEqual = std::equal_to<Key>,
+          typename Allocator = std::allocator<Key>>
+using Set = std::unordered_set<Key, Hash, KeyEqual, Allocator>;
+
+template <typename Key, typename Value, typename Hash = Hash<Key>,
+          typename KeyEqual = std::equal_to<Key>,
+          typename Allocator = std::allocator<std::pair<const Key, Value>>>
+using Map = std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>;
+
+template <typename Key, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<Key>>
+using OrderedSet = std::set<Key, Compare, Allocator>;
+
+template <typename Key, typename Value, typename Compare = std::less<Key>,
+          typename Allocator = std::allocator<std::pair<const Key, Value>>>
+using OrderedMap = std::map<Key, Value, Compare, Allocator>;
+
+typedef std::pair<NodeID, NodeID> NodePair;
+typedef OrderedSet<NodeID> OrderedNodeSet;
+typedef Set<NodeID> NodeSet;
+typedef Set<NodePair> NodePairSet;
+typedef Map<NodePair, NodeID> NodePairMap;
+typedef std::vector<NodeID> NodeVector;
+typedef std::vector<EdgeID> EdgeVector;
+typedef std::stack<NodeID> NodeStack;
+typedef std::list<NodeID> NodeList;
+typedef std::deque<NodeID> NodeDeque;
+typedef NodeSet EdgeSet;
+typedef std::vector<u32_t> CallStrCxt;
+typedef unsigned Version;
+typedef Set<Version> VersionSet;
+typedef std::pair<NodeID, Version> VersionedVar;
+typedef Set<VersionedVar> VersionedVarSet;
+}

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

@@ -0,0 +1,186 @@
+//===- GraphReachSolver.h -- Generic graph reachability solver---------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * GraphReachSolver.h
+ *
+ *  Created on: Apr 1, 2014
+ *      Author: Yulei Sui
+ */
+
+#ifndef CFLSOLVER_H_
+#define CFLSOLVER_H_
+
+#include "Util/WorkList.h"
+#include "Util/DPItem.h"
+
+namespace SVF
+{
+
+/*
+ * Generic Graph Reachability solver for demand-driven analysis based on different graphs (e.g. SVFIR, VFG, ThreadVFG)
+ * Extend this class for sophisticated CFL-reachability resolution (e.g. field, flow, path)
+ */
+template<class GraphType, class DPIm = DPItem>
+class GraphReachSolver
+{
+
+public:
+    ///Define the GTraits and node iterator
+    typedef SVF::GenericGraphTraits<GraphType> GTraits;
+    typedef typename GTraits::NodeType          GNODE;
+    typedef typename GTraits::EdgeType          GEDGE;
+    typedef typename GTraits::nodes_iterator node_iterator;
+    typedef typename GTraits::ChildIteratorType child_iterator;
+
+    /// Define inverse GTraits and note iterator
+    typedef SVF::GenericGraphTraits<SVF::Inverse<GNODE *> > InvGTraits;
+    typedef typename InvGTraits::ChildIteratorType inv_child_iterator;
+
+    /// Define worklist
+    typedef FIFOWorkList<DPIm> WorkList;
+
+protected:
+
+    /// Constructor
+    GraphReachSolver(): _graph(nullptr)
+    {
+    }
+    /// Destructor
+    virtual ~GraphReachSolver()
+    {
+    }
+    /// Get/Set graph methods
+    //@{
+    const inline GraphType graph() const
+    {
+        return _graph;
+    }
+    inline void setGraph(GraphType g)
+    {
+        _graph = g;
+    }
+    //@}
+
+    inline GNODE* getNode(NodeID id) const
+    {
+        return _graph->getGNode(id);
+    }
+    virtual inline NodeID getNodeIDFromItem(const DPIm& item) const
+    {
+        return item.getCurNodeID();
+    }
+    /// CFL forward traverse solve
+    virtual void forwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            FWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            child_iterator EI = GTraits::child_begin(v);
+            child_iterator EE = GTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                FWProcessOutgoingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// CFL forward traverse solve
+    virtual void backwardTraverse(DPIm& it)
+    {
+        pushIntoWorklist(it);
+
+        while (!isWorklistEmpty())
+        {
+            DPIm item = popFromWorklist();
+            BWProcessCurNode(item);
+
+            GNODE* v = getNode(getNodeIDFromItem(item));
+            inv_child_iterator EI = InvGTraits::child_begin(v);
+            inv_child_iterator EE = InvGTraits::child_end(v);
+            for (; EI != EE; ++EI)
+            {
+                BWProcessIncomingEdge(item,*(EI.getCurrent()) );
+            }
+        }
+    }
+    /// Process the DP item
+    //@{
+    virtual void FWProcessCurNode(const DPIm&)
+    {
+    }
+    virtual void BWProcessCurNode(const DPIm&)
+    {
+    }
+    //@}
+    /// Propagation for the solving, to be implemented in the child class
+    //@{
+    virtual void FWProcessOutgoingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getDstID());
+        pushIntoWorklist(newItem);
+    }
+    virtual void BWProcessIncomingEdge(const DPIm& item, GEDGE* edge)
+    {
+        DPIm newItem(item);
+        newItem.setCurNodeID(edge->getSrcID());
+        pushIntoWorklist(newItem);
+    }
+    //@}
+    /// Worklist operations
+    //@{
+    inline DPIm popFromWorklist()
+    {
+        return worklist.pop();
+    }
+    inline bool pushIntoWorklist(DPIm& item)
+    {
+        return worklist.push(item);
+    }
+    inline bool isWorklistEmpty()
+    {
+        return worklist.empty();
+    }
+    inline bool isInWorklist(DPIm& item)
+    {
+        return worklist.find(item);
+    }
+    //@}
+
+private:
+
+    /// Graph
+    GraphType _graph;
+
+    /// Worklist for resolution
+    WorkList worklist;
+
+};
+
+} // End namespace SVF
+
+#endif /* CFLSOLVER_H_ */

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

@@ -0,0 +1,203 @@
+//===- NodeIDAllocator.h -- Allocates node IDs on request ------------------------//
+
+#ifndef NODEIDALLOCATOR_H_
+#define NODEIDALLOCATOR_H_
+
+#include "FastCluster/fastcluster.h"
+#include "SVFIR/SVFType.h"
+#include "MemoryModel/PointsTo.h"
+
+namespace SVF
+{
+
+// Forward declare for the Clusterer.
+class BVDataPTAImpl;
+
+/// Allocates node IDs for objects and values, upon request, according to
+/// some strategy which can be user-defined.
+/// It is the job of SymbolTableInfo to tell the NodeIDAllocator when
+/// all symbols have been allocated through endSymbolAllocation.
+class NodeIDAllocator
+{
+    friend class SVFIRWriter;
+    friend class SVFIRReader;
+
+public:
+    /// Allocation strategy to use.
+    enum Strategy
+    {
+        /// Allocate objects contiguously, separate from values, and vice versa.
+        /// If [****...*****] is the space of unsigned integers, we allocate as,
+        /// [ssssooooooo...vvvvvvv] (o = object, v = value, s = special).
+        DENSE,
+        /// Like dense, but with order flipped:
+        /// [ssssvvvvvvv...ooooooo]
+        REVERSE_DENSE,
+        /// Allocate objects objects and values sequentially, intermixed.
+        SEQ,
+        /// Allocate values and objects as they come in with a single counter.
+        /// GEP objects are allocated as an offset from their base (see implementation
+        /// of allocateGepObjectId). The purpose of this allocation strategy
+        /// is human readability.
+        DBUG,
+    };
+
+    /// These nodes, and any nodes before them are assumed allocated
+    /// as objects and values. For simplicity's sake, numObjects and
+    /// numVals thus start at 4 (and the other counters are set
+    /// appropriately).
+    ///@{
+    static const NodeID blackHoleObjectId;
+    static const NodeID constantObjectId;
+    static const NodeID blackHolePointerId;
+    static const NodeID nullPointerId;
+    ///@}
+
+    /// Return (singleton) allocator.
+    static NodeIDAllocator *get(void);
+
+    /// Deletes the (singleton) allocator.
+    static void unset(void);
+
+    /// Allocate an object ID as determined by the strategy.
+    NodeID allocateObjectId(void);
+
+    /// Allocate a GEP object ID as determined by the strategy.
+    /// allocateObjectId is still fine for GEP objects, but
+    /// for some strategies (DBUG, namely), GEP objects can
+    /// be allocated differently (more readable, for DBUG).
+    /// Regardless, numObjects is shared; there is no special
+    /// numGepObjects.
+    NodeID allocateGepObjectId(NodeID base, u32_t offset, u32_t maxFieldLimit);
+
+    /// Allocate a value ID as determined by the strategy.
+    NodeID allocateValueId(void);
+
+    /// Notify the allocator that all symbols have had IDs allocated.
+    NodeID endSymbolAllocation(void);
+
+    /// Returns the total number of memory objects.
+    NodeID getNumObjects(void) const
+    {
+        return numObjects;
+    }
+
+    inline void increaseNumOfObjAndNodes()
+    {
+        ++numObjects;
+        ++numNodes;
+    }
+
+private:
+    /// Builds a node ID allocator with the strategy specified on the command line.
+    NodeIDAllocator(void);
+
+private:
+    /// These are moreso counters than amounts.
+    ///@{
+    /// Number of memory objects allocated, including specials.
+    NodeID numObjects;
+    /// Number of values allocated, including specials.
+    NodeID numValues;
+    /// Number of explicit symbols allocated (e.g., llvm::Values), including specials.
+    NodeID numSymbols;
+    /// Total number of objects and values allocated.
+    NodeID numNodes;
+    ///@}
+
+    /// Strategy to allocate with.
+    enum Strategy strategy;
+
+    /// Single allocator.
+    static NodeIDAllocator *allocator;
+
+public:
+    /// Perform clustering given points-to sets with nodes allocated according to the
+    /// DENSE strategy.
+    class Clusterer
+    {
+    private:
+        /// Maps a pair of nodes to their (minimum) distance and the number of
+        /// times that distance occurs in a set of *unique* points-to sets.
+        typedef Map<NodePair, std::pair<unsigned, unsigned>> DistOccMap;
+
+        /// Statistics strings.
+        ///@{
+        static const std::string NumObjects;
+        static const std::string RegioningTime;
+        static const std::string DistanceMatrixTime;
+        static const std::string FastClusterTime;
+        static const std::string DendrogramTraversalTime;
+        static const std::string EvalTime;
+        static const std::string TotalTime;
+        static const std::string TheoreticalNumWords;
+        static const std::string OriginalBvNumWords;
+        static const std::string OriginalSbvNumWords;
+        static const std::string NewBvNumWords;
+        static const std::string NewSbvNumWords;
+        static const std::string NumRegions;
+        static const std::string NumGtIntRegions;
+        static const std::string LargestRegion;
+        static const std::string BestCandidate;
+        static const std::string NumNonTrivialRegionObjects;
+        ///@}
+
+    public:
+        /// Returns vector mapping previously allocated node IDs to a smarter allocation
+        /// based on the points-to sets in pta accessed through keys.
+        /// The second part of the keys pairs are the number of (potential) occurrences of that points-to set
+        /// or a subset, depending on the client's wish.
+        /// TODO: interfaces are getting unwieldy, an initialised object may be better.
+        /// TODO: kind of sucks pta can't be const here because getPts isn't.
+        static std::vector<NodeID> cluster(BVDataPTAImpl *pta, const std::vector<std::pair<NodeID, unsigned>> keys, std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates, std::string evalSubtitle="");
+
+        // Returns a reverse node mapping for mapping generated by cluster().
+        static std::vector<NodeID> getReverseNodeMapping(const std::vector<NodeID> &nodeMapping);
+
+        /// Fills in *NumWords statistics in stats..
+        static void evaluate(const std::vector<NodeID> &nodeMap, const Map<PointsTo, unsigned> pointsToSets, Map<std::string, std::string> &stats, bool accountForOcc);
+
+        /// Prints statistics to SVFUtil::outs().
+        /// TODO: make stats const.
+        static void printStats(std::string title, Map<std::string, std::string> &stats);
+
+    private:
+        /// Returns an index into a condensed matrix (upper triangle, excluding diagonals) corresponding
+        /// to an nxn matrix.
+        static inline size_t condensedIndex(size_t n, size_t i, size_t j);
+
+        /// Returns the minimum number of bits required to represent pts in a perfect world.
+        static inline unsigned requiredBits(const PointsTo &pts);
+
+        /// Returns the minimum number of bits required to represent n items in a perfect world.
+        static inline unsigned requiredBits(const size_t n);
+
+        /// Builds the upper triangle of the distance matrix, as an array of length
+        /// (numObjects * (numObjects - 1)) / 2, as required by fastcluster.
+        /// Responsibility of caller to `delete`.
+        static inline double *getDistanceMatrix(const std::vector<std::pair<const PointsTo *, unsigned>> pointsToSets,
+                                                const size_t numObjects, const Map<NodeID, unsigned> &nodeMap,
+                                                double &distanceMatrixTime);
+
+        /// Traverses the dendrogram produced by fastcluster, making node o, where o is the nth leaf (per
+        /// recursive DFS) map to n. index is the dendrogram node to work off. The traversal should start
+        /// at the top, which is the "last" (consider that it is 2D) element of the dendrogram, numObjects - 1.
+        static inline void traverseDendrogram(std::vector<NodeID> &nodeMap, const int *dendrogram, const size_t numObjects, unsigned &allocCounter, Set<int> &visited, const int index, const std::vector<NodeID> &regionNodeMap);
+
+        /// Returns a vector mapping object IDs to a label such that if two objects appear
+        /// in the same points-to set, they have the same label. The "appear in the same
+        /// points-to set" is encoded by graph which is an adjacency list ensuring that
+        /// x in pt(p) and y in pt(p) -> x is reachable from y.
+        static inline std::vector<unsigned> regionObjects(const Map<NodeID, Set<NodeID>> &graph, size_t numObjects, size_t &numLabels);
+
+        // From all the candidates, returns the best mapping for pointsToSets (points-to set -> # occurrences).
+        static inline std::pair<hclust_fast_methods, std::vector<NodeID>> determineBestMapping(
+            const std::vector<std::pair<hclust_fast_methods, std::vector<NodeID>>> &candidates,
+            Map<PointsTo, unsigned> pointsToSets, const std::string &evalSubtitle, double &evalTime);
+
+    };
+};
+
+}  // namespace SVF
+
+#endif  // ifdef NODEIDALLOCATOR_H_