svf-lib 1.0.2237 → 1.0.2239

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

@@ -0,0 +1,189 @@
+//===- ThreadAPI.h -- API for threads-----------------------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * ThreadAPI.h
+ *
+ *  Created on: Jan 21, 2014
+ *      Author: Yulei Sui, dye
+ */
+
+#ifndef THREADAPI_H_
+#define THREADAPI_H_
+
+#include "SVFIR/SVFValue.h"
+
+namespace SVF
+{
+
+class SVFModule;
+class ICFGNode;
+class CallICFGNode;
+class SVFVar;
+class ValVar;
+class ObjVar;
+class FunObjVar;
+
+/*
+ * ThreadAPI class contains interfaces for pthread programs
+ */
+class ThreadAPI
+{
+
+public:
+    enum TD_TYPE
+    {
+        TD_DUMMY = 0,   /// dummy type
+        TD_FORK,        /// create a new thread
+        TD_JOIN,        /// wait for a thread to join
+        TD_DETACH,      /// detach a thread directly instead wait for it to join
+        TD_ACQUIRE,     /// acquire a lock
+        TD_TRY_ACQUIRE, /// try to acquire a lock
+        TD_RELEASE,     /// release a lock
+        TD_EXIT,        /// exit/kill a thread
+        TD_CANCEL,      /// cancel a thread by another
+        TD_COND_WAIT,   /// wait a condition
+        TD_COND_SIGNAL, /// signal a condition
+        TD_COND_BROADCAST,  /// broadcast a condition
+        TD_MUTEX_INI,       /// initial a mutex variable
+        TD_MUTEX_DESTROY,   /// initial a mutex variable
+        TD_CONDVAR_INI,     /// initial a mutex variable
+        TD_CONDVAR_DESTROY, /// initial a mutex variable
+        TD_BAR_INIT,        /// Barrier init
+        TD_BAR_WAIT,        /// Barrier wait
+        HARE_PAR_FOR
+    };
+
+    typedef Map<std::string, TD_TYPE> TDAPIMap;
+
+private:
+    /// API map, from a string to threadAPI type
+    TDAPIMap tdAPIMap;
+
+    /// Constructor
+    ThreadAPI ()
+    {
+        init();
+    }
+
+    /// Initialize the map
+    void init();
+
+    /// Static reference
+    static ThreadAPI* tdAPI;
+
+    /// Get the function type if it is a threadAPI function
+    TD_TYPE getType(const FunObjVar* F) const;
+
+public:
+    /// Return a static reference
+    static ThreadAPI* getThreadAPI()
+    {
+        if(tdAPI == nullptr)
+        {
+            tdAPI = new ThreadAPI();
+        }
+        return tdAPI;
+    }
+
+    static void destroy()
+    {
+        if(tdAPI != nullptr)
+        {
+            delete tdAPI;
+            tdAPI = nullptr;
+        }
+    }
+
+    /// Return arguments/attributes of pthread_create / hare_parallel_for
+    //@{
+    /// Return the first argument of the call,
+    /// Note that, it is the pthread_t pointer
+    const ValVar* getForkedThread(const CallICFGNode *inst) const;
+    /// Return the third argument of the call,
+    /// Note that, it could be function type or a void* pointer
+    const ValVar* getForkedFun(const CallICFGNode *inst) const;
+
+    /// Return the forth argument of the call,
+    /// Note that, it is the sole argument of start routine ( a void* pointer )
+    const ValVar* getActualParmAtForkSite(const CallICFGNode *inst) const;
+
+    /// Return the formal parm of forked function (the first arg in pthread)
+    const SVFVar* getFormalParmOfForkedFun(const FunObjVar* F) const;
+    //@}
+
+
+
+    /// Return true if this call create a new thread
+    //@{
+    bool isTDFork(const CallICFGNode *inst) const;
+    //@}
+
+    /// Return true if this call wait for a worker thread
+    //@{
+    bool isTDJoin(const CallICFGNode *inst) const;
+    //@}
+
+    /// Return arguments/attributes of pthread_join
+    //@{
+    /// Return the first argument of the call,
+    /// Note that, it is the pthread_t pointer
+    const SVFVar* getJoinedThread(const CallICFGNode *inst) const;
+    /// Return the send argument of the call,
+    /// Note that, it is the pthread_t pointer
+    const SVFVar* getRetParmAtJoinedSite(const CallICFGNode *inst) const;
+    //@}
+
+
+    /// Return true if this call exits/terminate a thread
+    //@{
+    bool isTDExit(const CallICFGNode *inst) const;
+    //@}
+
+    /// Return true if this call acquire a lock
+    //@{
+    bool isTDAcquire(const CallICFGNode* inst) const;
+    //@}
+
+    /// Return true if this call release a lock
+    //@{
+    bool isTDRelease(const CallICFGNode *inst) const;
+    //@}
+
+    /// Return lock value
+    //@{
+    /// First argument of pthread_mutex_lock/pthread_mutex_unlock
+    const SVFVar* getLockVal(const ICFGNode *inst) const;
+    //@}
+
+    /// Return true if this call waits for a barrier
+    //@{
+    bool isTDBarWait(const CallICFGNode *inst) const;
+    //@}
+
+    void performAPIStat();
+    void statInit(Map<std::string, u32_t>& tdAPIStatMap);
+};
+
+} // End namespace SVF
+
+#endif /* THREADAPI_H_ */

package/SVF-linux-aarch64/Release-build/include/Util/WorkList.h

@@ -0,0 +1,317 @@
+//===- WorkList.h -- Internal worklist used in SVF---------------------------//
+//
+//                     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/>.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+ * @file: WorkList.h
+ * @author: yesen
+ * @date: 06/12/2013
+ * @version: 1.0
+ *
+ * @section LICENSE
+ *
+ * @section DESCRIPTION
+ *
+ */
+
+
+#ifndef WORKLIST_H_
+#define WORKLIST_H_
+
+#include "SVFIR/SVFValue.h"
+
+#include <assert.h>
+#include <cstdlib>
+#include <vector>
+#include <deque>
+#include <set>
+
+namespace SVF
+{
+
+/**
+ * Worklist with "first come first go" order.
+ * New nodes pushed at back and popped from front.
+ * Elements in the list are unique as they're recorded by Set.
+ */
+template<class Data>
+class List
+{
+    class ListNode
+    {
+    public:
+        ListNode(const Data &d)
+        {
+            data = d;
+            next = nullptr;
+        }
+
+        ~ListNode() {}
+
+        Data data;
+        ListNode *next;
+    };
+
+    typedef Set<Data> DataSet;
+    typedef ListNode Node;
+
+public:
+    List()
+    {
+        head = nullptr;
+        tail = nullptr;
+    }
+
+    ~List() {}
+
+    inline bool empty() const
+    {
+        return (head == nullptr);
+    }
+
+    inline bool find(const Data &data) const
+    {
+        return nodeSet.find(data) != nodeSet.end();
+    }
+
+    void push(const Data &data)
+    {
+        if (nodeSet.find(data) == nodeSet.end())
+        {
+            Node *new_node = new Node(data);
+            if (head == nullptr)
+                head = new_node;// the list is empty
+            else
+                tail->next = new_node;
+            tail = new_node;
+        }
+    }
+
+    Data pop()
+    {
+        assert(head != nullptr && "list is empty");
+        /// get node from list head
+        Node *head_node = head;
+
+        /// change list head to the next node
+        head = head->next;
+        if (head == nullptr)
+            tail = nullptr;    /// the last node is popped.
+
+        Data data = head_node->data;
+        nodeSet.erase(data);
+        delete head_node;
+        return data;
+    }
+
+private:
+    DataSet nodeSet;
+    Node *head;
+    Node *tail;
+};
+
+/**
+ * Worklist with "first in first out" order.
+ * New nodes will be pushed at back and popped from front.
+ * Elements in the list are unique as they're recorded by Set.
+ */
+template<class Data>
+class FIFOWorkList
+{
+    typedef Set<Data> DataSet;
+    typedef std::deque<Data> DataDeque;
+public:
+    FIFOWorkList() {}
+
+    ~FIFOWorkList() {}
+
+    inline bool empty() const
+    {
+        return data_list.empty();
+    }
+
+    inline u32_t size() const
+    {
+        assert(data_list.size() == data_set.size() && "list and set must be the same size!");
+        return data_list.size();
+    }
+
+    inline bool find(const Data &data) const
+    {
+        return data_set.find(data) != data_set.end();
+    }
+
+    /**
+     * Push a data into the work list.
+     */
+    inline bool push(const Data &data)
+    {
+        if (!find(data))
+        {
+            data_list.push_back(data);
+            data_set.insert(data);
+            return true;
+        }
+        else
+            return false;
+    }
+
+    /**
+     * Remove a data from the END of work list, no return value
+     */
+    inline void removeFront()
+    {
+        assert(!empty() && "work list is empty");
+        data_set.erase(front());
+        data_list.pop_front();
+    }
+
+    /**
+     * Get reference of top data from the END of work list.
+     */
+    inline Data &front()
+    {
+        assert(!empty() && "work list is empty");
+        Data &data = data_list.front();
+        return data;
+    }
+
+    /**
+     * Pop a data from the END of work list.
+     */
+    inline Data pop()
+    {
+        assert(!empty() && "work list is empty");
+        Data data = data_list.front();
+        data_list.pop_front();
+        data_set.erase(data);
+        return data;
+    }
+
+    /*!
+     * Clear all the data
+     */
+    inline void clear()
+    {
+        data_list.clear();
+        data_set.clear();
+    }
+
+private:
+    DataSet data_set;    ///< store all data in the work list.
+    DataDeque data_list;    ///< work list using std::vector.
+};
+
+/**
+ * Worklist with "first in last out" order.
+ * New nodes will be pushed at back and popped from back.
+ * Elements in the list are unique as they're recorded by Set.
+ */
+template<class Data>
+class FILOWorkList
+{
+    typedef Set<Data> DataSet;
+    typedef std::vector<Data> DataVector;
+public:
+    FILOWorkList() {}
+
+    ~FILOWorkList() {}
+
+    inline bool empty() const
+    {
+        return data_list.empty();
+    }
+
+    inline u32_t size() const
+    {
+        assert(data_list.size() == data_set.size() && "list and set must be the same size!");
+        return data_list.size();
+    }
+
+    inline bool find(const Data &data) const
+    {
+        return data_set.find(data) != data_set.end();;
+    }
+
+    /**
+     * Push a data into the work list.
+     */
+    inline bool push(const Data &data)
+    {
+        if (!find(data))
+        {
+            data_list.push_back(data);
+            data_set.insert(data);
+            return true;
+        }
+        else
+            return false;
+    }
+
+    /**
+     * Pop a data from the END of work list.
+     */
+    inline Data pop()
+    {
+        assert(!empty() && "work list is empty");
+        Data data = data_list.back();
+        data_list.pop_back();
+        data_set.erase(data);
+        return data;
+    }
+
+    /**
+     * Remove a data from the END of work list, no return value
+     */
+    inline void removeBack()
+    {
+        assert(!empty() && "work list is empty");
+        data_set.erase(back());
+        data_list.pop_back();
+    }
+
+    /**
+     * Get reference of top data from the END of work list.
+     */
+    inline Data &back()
+    {
+        assert(!empty() && "work list is empty");
+        Data &data = data_list.back();
+        return data;
+    }
+
+    /*!
+     * Clear all the data
+     */
+    inline void clear()
+    {
+        data_list.clear();
+        data_set.clear();
+    }
+
+private:
+    DataSet data_set;    ///< store all data in the work list.
+    DataVector data_list;    ///< work list using std::vector.
+};
+
+} // End namespace SVF
+
+#endif /* WORKLIST_H_ */