svf-tools 1.0.693 → 1.0.695

package/svf/include/SVFIR/SymbolTableInfo.h

@@ -48,6 +48,7 @@ class SymbolTableInfo
 {
     friend class SymbolTableBuilder;
     friend class SVFIRWriter;
+    friend class SVFIRReader;
 
 public:
 
@@ -288,6 +289,19 @@ public:
 
     //@}
 
+    /// Constant reader that won't change the state of the symbol table
+    //@{
+    inline const SVFTypeSet& getSVFTypes() const
+    {
+        return svfTypes;
+    }
+
+    inline const Set<const StInfo*>& getStInfos() const
+    {
+        return stInfos;
+    }
+    //@}
+
     /// Get struct info
     //@{
     ///Get a reference to StructInfo.
@@ -329,8 +343,13 @@ public:
 
     inline void addTypeInfo(const SVFType* ty)
     {
-        assert(!hasSVFTypeInfo(ty) && "this type info has been added before");
-        svfTypes.insert(ty);
+        bool inserted = svfTypes.insert(ty).second;
+        assert(inserted && "this type info has been added before");
+    }
+
+    inline void addStInfo(StInfo* stInfo)
+    {
+        stInfos.insert(stInfo);
     }
 
 protected:
@@ -341,11 +360,15 @@ protected:
     /// Create an objectInfo based on LLVM type (value is null, and type could be null, representing a dummy object)
     ObjTypeInfo* createObjTypeInfo(const SVFType* type);
 
+    /// (owned) All SVF Types
     /// Every type T is mapped to StInfo
     /// which contains size (fsize) , offset(foffset)
     /// fsize[i] is the number of fields in the largest such struct, else fsize[i] = 1.
     /// fsize[0] is always the size of the expanded struct.
     SVFTypeSet svfTypes;
+
+    /// @brief (owned) All StInfo
+    Set<const StInfo*> stInfos;
 };
 
 
@@ -355,6 +378,7 @@ protected:
 class MemObj
 {
     friend class SVFIRWriter;
+    friend class SVFIRReader;
 
 private:
     /// Type information of this object
@@ -447,6 +471,7 @@ public:
 class ObjTypeInfo
 {
     friend class SVFIRWriter;
+    friend class SVFIRReader;
     friend class SymbolTableBuilder;
 
 public:

package/svf/include/Util/Options.h

@@ -135,6 +135,7 @@ public:
     static const Option<bool> ShowSVFIRValue;
     static const Option<bool> DumpICFG;
     static const Option<std::string> DumpJson;
+    static const Option<bool> ReadJson;
     static const Option<bool> CallGraphDotGraph;
     static const Option<bool> PAGPrint;
     static const Option<u32_t> IndirectCallLimit;

package/svf/include/Util/SVFUtil.h

@@ -654,6 +654,55 @@ move(T &&t) noexcept
     return std::move(t);
 }
 
+/// void_t is not avaiable until C++17. We define it here for C++11/14.
+template <typename... Ts> struct make_void
+{
+    typedef void type;
+};
+template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+
+/// @brief Type trait that checks if a type is iterable
+/// (can be applied on a range-based for loop)
+///@{
+template <typename T, typename = void> struct is_iterable : std::false_type {};
+template <typename T>
+struct is_iterable<T, void_t<decltype(std::begin(std::declval<T&>()) !=
+                                      std::end(std::declval<T&>()))>>
+: std::true_type {};
+template <typename T> constexpr bool is_iterable_v = is_iterable<T>::value;
+///@}
+
+/// @brief Type trait to check if a type is a map or unordered_map.
+///@{
+template <typename T> struct is_map : std::false_type {};
+template <typename... Ts> struct is_map<std::map<Ts...>> : std::true_type {};
+template <typename... Ts>
+struct is_map<std::unordered_map<Ts...>> : std::true_type {};
+template <typename... Ts> constexpr bool is_map_v = is_map<Ts...>::value;
+///@}
+
+/// @brief Type trait to check if a type is a set or unordered_set.
+///@{
+template <typename T> struct is_set : std::false_type {};
+template <typename... Ts> struct is_set<std::set<Ts...>> : std::true_type {};
+template <typename... Ts>
+struct is_set<std::unordered_set<Ts...>> : std::true_type {};
+template <typename... Ts> constexpr bool is_set_v = is_set<Ts...>::value;
+///@}
+
+/// @brief Type trait to check if a type is vector or list.
+template <typename T> struct is_sequence_container : std::false_type {};
+template <typename... Ts>
+struct is_sequence_container<std::vector<Ts...>> : std::true_type {};
+template <typename... Ts>
+struct is_sequence_container<std::deque<Ts...>> : std::true_type {};
+template <typename... Ts>
+struct is_sequence_container<std::list<Ts...>> : std::true_type {};
+template <typename... Ts>
+constexpr bool is_sequence_container_v = is_sequence_container<Ts...>::value;
+///@}
+
+
 } // End namespace SVFUtil
 
 } // End namespace SVF

package/svf/include/Util/SparseBitVector.h

@@ -217,6 +217,7 @@ inline unsigned countPopulation(T Value)
 template <unsigned ElementSize = 128> struct SparseBitVectorElement
 {
     friend class SVFIRWriter;
+    friend class SVFIRReader;
 
 public:
     using BitWord = unsigned long;
@@ -458,6 +459,7 @@ template <unsigned ElementSize = 128>
 class SparseBitVector
 {
     friend class SVFIRWriter;
+    friend class SVFIRReader;
 
     using ElementList = std::list<SparseBitVectorElement<ElementSize>>;
     using ElementListIter = typename ElementList::iterator;