svf-lib 1.0.1294 → 1.0.1296

package/SVF-osx/include/Graphs/CFLGraph.h

@@ -189,23 +189,23 @@ private:
 
 }
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::CFLNode*> : public GraphTraits<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>*  >
+template<> struct GenericGraphTraits<SVF::CFLNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::CFLNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::CFLNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CFLNode,SVF::CFLEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::CFLGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CFLNode,SVF::CFLEdge>* >
+template<> struct GenericGraphTraits<SVF::CFLGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CFLNode,SVF::CFLEdge>* >
 {
     typedef SVF::CFLNode *NodeRef;
 };

package/SVF-osx/include/Graphs/CHG.h

@@ -325,23 +325,23 @@ private:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::CHNode*> : public GraphTraits<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>*  >
+template<> struct GenericGraphTraits<SVF::CHNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::CHNode*> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::CHNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::CHNode,SVF::CHEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::CHGraph*> : public GraphTraits<SVF::GenericGraph<SVF::CHNode,SVF::CHEdge>* >
+template<> struct GenericGraphTraits<SVF::CHGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::CHNode,SVF::CHEdge>* >
 {
     typedef SVF::CHNode *NodeRef;
 };

package/SVF-osx/include/Graphs/ConsG.h

@@ -382,23 +382,23 @@ public:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for the generic graph algorithms.
+ * GenericGraphTraits specializations for the generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::ConstraintNode*> : public GraphTraits<SVF::GenericNode<SVF::ConstraintNode,SVF::ConstraintEdge>*  >
+template<> struct GenericGraphTraits<SVF::ConstraintNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::ConstraintNode,SVF::ConstraintEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for Value flow node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::ConstraintNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::ConstraintNode,SVF::ConstraintEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::ConstraintNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::ConstraintNode,SVF::ConstraintEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::ConstraintGraph*> : public GraphTraits<SVF::GenericGraph<SVF::ConstraintNode,SVF::ConstraintEdge>* >
+template<> struct GenericGraphTraits<SVF::ConstraintGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::ConstraintNode,SVF::ConstraintEdge>* >
 {
     typedef SVF::ConstraintNode *NodeRef;
 };

package/SVF-osx/include/Graphs/DOTGraphTraits.h

@@ -13,12 +13,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_DOTGRAPHTRAITS_H
-#define LLVM_SUPPORT_DOTGRAPHTRAITS_H
+#ifndef GRAPHS_DOTGRAPHTRAITS_H
+#define GRAPHS_DOTGRAPHTRAITS_H
 
 #include <string>
 
-namespace llvm
+namespace SVF
 {
 
 /// DefaultDOTGraphTraits - This class provides the default implementations of

package/SVF-osx/include/Graphs/GenericGraph.h

@@ -32,6 +32,7 @@
 
 #include "SVFIR/SVFValue.h"
 #include "Util/iterator.h"
+#include "Graphs/GraphTraits.h"
 
 namespace SVF
 {
@@ -447,10 +448,10 @@ public:
 } // End namespace SVF
 
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for tranversing from a node using standard graph traversals.
  */
-namespace llvm
+namespace SVF
 {
 
 // mapped_iter - This is a simple iterator adapter that causes a function to
@@ -460,14 +461,14 @@ template <typename ItTy, typename FuncTy,
           typename FuncReturnTy =
           decltype(std::declval<FuncTy>()(*std::declval<ItTy>()))>
 class mapped_iter
-    : public iterator_adaptor_base<
+    : public iter_adaptor_base<
       mapped_iter<ItTy, FuncTy>, ItTy,
       typename std::iterator_traits<ItTy>::iterator_category,
       typename std::remove_reference<FuncReturnTy>::type>
 {
 public:
     mapped_iter(ItTy U, FuncTy F)
-        : mapped_iter::iterator_adaptor_base(std::move(U)), F(std::move(F)) {}
+        : mapped_iter::iter_adaptor_base(std::move(U)), F(std::move(F)) {}
 
     ItTy getCurrent()
     {
@@ -492,9 +493,9 @@ inline mapped_iter<ItTy, FuncTy> map_iter(ItTy I, FuncTy F)
 }
 
 /*!
- * GraphTraits for nodes
+ * GenericGraphTraits for nodes
  */
-template<class NodeTy,class EdgeTy> struct GraphTraits<SVF::GenericNode<NodeTy,EdgeTy>*  >
+template<class NodeTy,class EdgeTy> struct GenericGraphTraits<SVF::GenericNode<NodeTy,EdgeTy>*  >
 {
     typedef NodeTy NodeType;
     typedef EdgeTy EdgeType;
@@ -531,10 +532,10 @@ template<class NodeTy,class EdgeTy> struct GraphTraits<SVF::GenericNode<NodeTy,E
 };
 
 /*!
- * Inverse GraphTraits for node which is used for inverse traversal.
+ * Inverse GenericGraphTraits for node which is used for inverse traversal.
  */
 template<class NodeTy,class EdgeTy>
-struct GraphTraits<Inverse<SVF::GenericNode<NodeTy,EdgeTy>* > >
+struct GenericGraphTraits<Inverse<SVF::GenericNode<NodeTy,EdgeTy>* > >
 {
     typedef NodeTy NodeType;
     typedef EdgeTy EdgeType;
@@ -570,7 +571,7 @@ struct GraphTraits<Inverse<SVF::GenericNode<NodeTy,EdgeTy>* > >
 /*!
  * GraphTraints
  */
-template<class NodeTy,class EdgeTy> struct GraphTraits<SVF::GenericGraph<NodeTy,EdgeTy>* > : public GraphTraits<SVF::GenericNode<NodeTy,EdgeTy>*  >
+template<class NodeTy,class EdgeTy> struct GenericGraphTraits<SVF::GenericGraph<NodeTy,EdgeTy>* > : public GenericGraphTraits<SVF::GenericNode<NodeTy,EdgeTy>*  >
 {
     typedef SVF::GenericGraph<NodeTy,EdgeTy> GenericGraphTy;
     typedef NodeTy NodeType;

package/SVF-osx/include/Graphs/GraphPrinter.h

@@ -35,7 +35,7 @@
 #include "Graphs/GraphWriter.h"	// for graph write
 #include <fstream>
 
-namespace llvm
+namespace SVF
 {
 
 /*
@@ -80,7 +80,7 @@ public:
                            const GraphType &GT)
     {
         ///Define the GTraits and node iterator for printing
-        typedef llvm::GraphTraits<GraphType> GTraits;
+        typedef GenericGraphTraits<GraphType> GTraits;
 
         typedef typename GTraits::NodeRef NodeRef;
         typedef typename GTraits::nodes_iterator node_iterator;

package/SVF-osx/include/Graphs/GraphTraits.h

@@ -1,4 +1,4 @@
-//===- llvm/ADT/GraphTraits.h - Graph traits template -----------*- C++ -*-===//
+//===- llvm/ADT/GenericGraphTraits.h - Graph traits template -----------*- C++ -*-===//
 //
 // From the LLVM Project with some modifications, under the Apache License v2.0
 // with LLVM Exceptions. See https://llvm.org/LICENSE.txt for license information.
@@ -6,7 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the little GraphTraits<X> template class that should be
+// This file defines the little GenericGraphTraits<X> template class that should be
 // specialized by classes that want to be iteratable by generic graph iterators.
 //
 // This file also defines the marker class Inverse that is used to iterate over
@@ -14,26 +14,26 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ADT_GRAPHTRAITS_H
-#define LLVM_ADT_GRAPHTRAITS_H
+#ifndef GRAPHS_GRAPHTRAITS_H
+#define GRAPHS_GRAPHTRAITS_H
 
 #include "Util/iterator_range.h"
 
-namespace llvm
+namespace SVF
 {
 
-// GraphTraits - This class should be specialized by different graph types...
+// GenericGraphTraits - This class should be specialized by different graph types...
 // which is why the default version is empty.
 //
 // This template evolved from supporting `BasicBlock` to also later supporting
 // more complex types (e.g. CFG and DomTree).
 //
-// GraphTraits can be used to create a view over a graph interpreting it
+// GenericGraphTraits can be used to create a view over a graph interpreting it
 // differently without requiring a copy of the original graph. This could
 // be achieved by carrying more data in NodeRef. See LoopBodyTraits for one
 // example.
 template<class GraphType>
-struct GraphTraits
+struct GenericGraphTraits
 {
     // Elements to provide:
 
@@ -73,7 +73,7 @@ struct GraphTraits
 
     // If anyone tries to use this class without having an appropriate
     // specialization, make an error.  If you get this error, it's because you
-    // need to include the appropriate specialization of GraphTraits<> for your
+    // need to include the appropriate specialization of GenericGraphTraits<> for your
     // graph, or you need to define it for a new graph type. Either that or
     // your argument to XXX_begin(...) is unknown or needs to have the proper .h
     // file #include'd.
@@ -101,48 +101,48 @@ struct Inverse
     inline Inverse(const GraphType &G) : Graph(G) {}
 };
 
-// Provide a partial specialization of GraphTraits so that the inverse of an
+// Provide a partial specialization of GenericGraphTraits so that the inverse of an
 // inverse falls back to the original graph.
-template <class T> struct GraphTraits<Inverse<Inverse<T>>> : GraphTraits<T> {};
+template <class T> struct GenericGraphTraits<Inverse<Inverse<T>>> : GenericGraphTraits<T> {};
 
 // Provide iterator ranges for the graph traits nodes and children
 template <class GraphType>
-iterator_range<typename GraphTraits<GraphType>::nodes_iterator>
+iter_range<typename GenericGraphTraits<GraphType>::nodes_iterator>
 nodes(const GraphType &G)
 {
-    return make_range(GraphTraits<GraphType>::nodes_begin(G),
-                      GraphTraits<GraphType>::nodes_end(G));
+    return make_range(GenericGraphTraits<GraphType>::nodes_begin(G),
+                      GenericGraphTraits<GraphType>::nodes_end(G));
 }
 template <class GraphType>
-iterator_range<typename GraphTraits<Inverse<GraphType>>::nodes_iterator>
+iter_range<typename GenericGraphTraits<Inverse<GraphType>>::nodes_iterator>
         inverse_nodes(const GraphType &G)
 {
-    return make_range(GraphTraits<Inverse<GraphType>>::nodes_begin(G),
-                      GraphTraits<Inverse<GraphType>>::nodes_end(G));
+    return make_range(GenericGraphTraits<Inverse<GraphType>>::nodes_begin(G),
+                      GenericGraphTraits<Inverse<GraphType>>::nodes_end(G));
 }
 
 template <class GraphType>
-iterator_range<typename GraphTraits<GraphType>::ChildIteratorType>
-children(const typename GraphTraits<GraphType>::NodeRef &G)
+iter_range<typename GenericGraphTraits<GraphType>::ChildIteratorType>
+children(const typename GenericGraphTraits<GraphType>::NodeRef &G)
 {
-    return make_range(GraphTraits<GraphType>::child_begin(G),
-                      GraphTraits<GraphType>::child_end(G));
+    return make_range(GenericGraphTraits<GraphType>::child_begin(G),
+                      GenericGraphTraits<GraphType>::child_end(G));
 }
 
 template <class GraphType>
-iterator_range<typename GraphTraits<Inverse<GraphType>>::ChildIteratorType>
-        inverse_children(const typename GraphTraits<GraphType>::NodeRef &G)
+iter_range<typename GenericGraphTraits<Inverse<GraphType>>::ChildIteratorType>
+        inverse_children(const typename GenericGraphTraits<GraphType>::NodeRef &G)
 {
-    return make_range(GraphTraits<Inverse<GraphType>>::child_begin(G),
-                      GraphTraits<Inverse<GraphType>>::child_end(G));
+    return make_range(GenericGraphTraits<Inverse<GraphType>>::child_begin(G),
+                      GenericGraphTraits<Inverse<GraphType>>::child_end(G));
 }
 
 template <class GraphType>
-iterator_range<typename GraphTraits<GraphType>::ChildEdgeIteratorType>
-children_edges(const typename GraphTraits<GraphType>::NodeRef &G)
+iter_range<typename GenericGraphTraits<GraphType>::ChildEdgeIteratorType>
+children_edges(const typename GenericGraphTraits<GraphType>::NodeRef &G)
 {
-    return make_range(GraphTraits<GraphType>::child_edge_begin(G),
-                      GraphTraits<GraphType>::child_edge_end(G));
+    return make_range(GenericGraphTraits<GraphType>::child_edge_begin(G),
+                      GenericGraphTraits<GraphType>::child_edge_end(G));
 }
 
 } // end namespace llvm

package/SVF-osx/include/Graphs/GraphWriter.h

@@ -19,8 +19,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_SUPPORT_GRAPHWRITER_H
-#define LLVM_SUPPORT_GRAPHWRITER_H
+#ifndef GRAPHS_GRAPHWRITER_H
+#define GRAPHS_GRAPHWRITER_H
 
 #include "Graphs/GraphTraits.h"
 #include "Graphs/DOTGraphTraits.h"
@@ -34,7 +34,7 @@
 #include <sstream>
 #include <iostream>
 
-namespace llvm
+namespace SVF
 {
 
 namespace DOT    // Private functions...
@@ -65,7 +65,7 @@ class GraphWriter
     const GraphType &G;
 
     using DOTTraits = DOTGraphTraits<GraphType>;
-    using GTraits = GraphTraits<GraphType>;
+    using GTraits = GenericGraphTraits<GraphType>;
     using NodeRef = typename GTraits::NodeRef;
     using node_iterator = typename GTraits::nodes_iterator;
     using child_iterator = typename GTraits::ChildIteratorType;
@@ -356,7 +356,7 @@ std::string WriteGraph(const GraphType &G,
         return "";
     }
 
-    llvm::WriteGraph(O, G, ShortNames);
+    SVF::WriteGraph(O, G, ShortNames);
     O.close();
 
     std::cerr << " done. \n";
@@ -372,7 +372,7 @@ void ViewGraph(const GraphType &G,const std::string& name,
                bool ShortNames = false,
                GraphProgram::Name Program = GraphProgram::DOT)
 {
-    llvm::WriteGraph(G, ShortNames);
+    SVF::WriteGraph(G, ShortNames);
 }
 
 } // end namespace llvm

package/SVF-osx/include/Graphs/ICFG.h

@@ -305,23 +305,23 @@ private:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::ICFGNode*> : public GraphTraits<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>*  >
+template<> struct GenericGraphTraits<SVF::ICFGNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::ICFGNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::ICFGNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::ICFGNode,SVF::ICFGEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::ICFG*> : public GraphTraits<SVF::GenericGraph<SVF::ICFGNode,SVF::ICFGEdge>* >
+template<> struct GenericGraphTraits<SVF::ICFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::ICFGNode,SVF::ICFGEdge>* >
 {
     typedef SVF::ICFGNode *NodeRef;
 };

package/SVF-osx/include/Graphs/IRGraph.h

@@ -218,24 +218,23 @@ public:
 
 }
 
-
-namespace llvm
+namespace SVF
 {
 
 /* !
- * GraphTraits specializations of SVFIR to be used for the generic graph algorithms.
+ * GenericGraphTraits specializations of SVFIR to be used for the generic graph algorithms.
  * Provide graph traits for tranversing from a SVFIR node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::SVFVar*> : public GraphTraits<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>*  >
+template<> struct GenericGraphTraits<SVF::SVFVar*> : public GenericGraphTraits<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for SVFIR node, it is used for inverse traversal.
-template<> struct GraphTraits<Inverse<SVF::SVFVar *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>* > >
+/// Inverse GenericGraphTraits specializations for SVFIR node, it is used for inverse traversal.
+template<> struct GenericGraphTraits<Inverse<SVF::SVFVar *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::SVFVar,SVF::SVFStmt>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::IRGraph*> : public GraphTraits<SVF::GenericGraph<SVF::SVFVar,SVF::SVFStmt>* >
+template<> struct GenericGraphTraits<SVF::IRGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::SVFVar,SVF::SVFStmt>* >
 {
     typedef SVF::SVFVar *NodeRef;
 };

package/SVF-osx/include/Graphs/PTACallGraph.h

@@ -445,23 +445,23 @@ public:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::PTACallGraphNode*> : public GraphTraits<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>*  >
+template<> struct GenericGraphTraits<SVF::PTACallGraphNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::PTACallGraphNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::PTACallGraphNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::PTACallGraph*> : public GraphTraits<SVF::GenericGraph<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* >
+template<> struct GenericGraphTraits<SVF::PTACallGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::PTACallGraphNode,SVF::PTACallGraphEdge>* >
 {
     typedef SVF::PTACallGraphNode *NodeRef;
 };

package/SVF-osx/include/Graphs/SVFG.h

@@ -461,21 +461,21 @@ protected:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for SVFG to be used for generic graph algorithms.
+ * GenericGraphTraits specializations for SVFG to be used for generic graph algorithms.
  * Provide graph traits for traversing from a SVFG node using standard graph traversals.
  */
-//template<> struct GraphTraits<SVF::SVFGNode*>: public GraphTraits<SVF::GenericNode<SVF::SVFGNode,SVF::SVFGEdge>*  > {
+//template<> struct GenericGraphTraits<SVF::SVFGNode*>: public GenericGraphTraits<SVF::GenericNode<SVF::SVFGNode,SVF::SVFGEdge>*  > {
 //};
 //
-///// Inverse GraphTraits specializations for Value flow node, it is used for inverse traversal.
+///// Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal.
 //template<>
-//struct GraphTraits<Inverse<SVF::SVFGNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::SVFGNode,SVF::SVFGEdge>* > > {
+//struct GenericGraphTraits<Inverse<SVF::SVFGNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::SVFGNode,SVF::SVFGEdge>* > > {
 //};
 
-template<> struct GraphTraits<SVF::SVFG*> : public GraphTraits<SVF::GenericGraph<SVF::SVFGNode,SVF::SVFGEdge>* >
+template<> struct GenericGraphTraits<SVF::SVFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::SVFGNode,SVF::SVFGEdge>* >
 {
     typedef SVF::SVFGNode *NodeRef;
 };

package/SVF-osx/include/Graphs/VFG.h

@@ -638,23 +638,23 @@ protected:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::VFGNode*> : public GraphTraits<SVF::GenericNode<SVF::VFGNode,SVF::VFGEdge>*  >
+template<> struct GenericGraphTraits<SVF::VFGNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::VFGNode,SVF::VFGEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::VFGNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::VFGNode,SVF::VFGEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::VFGNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::VFGNode,SVF::VFGEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::VFG*> : public GraphTraits<SVF::GenericGraph<SVF::VFGNode,SVF::VFGEdge>* >
+template<> struct GenericGraphTraits<SVF::VFG*> : public GenericGraphTraits<SVF::GenericGraph<SVF::VFGNode,SVF::VFGEdge>* >
 {
     typedef SVF::VFGNode *NodeRef;
 };

package/SVF-osx/include/MTA/TCT.h

@@ -572,24 +572,24 @@ private:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for constraint graph so that they can be treated as
+ * GenericGraphTraits specializations for constraint graph so that they can be treated as
  * graphs by the generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::TCTNode*> : public GraphTraits<SVF::GenericNode<SVF::TCTNode,SVF::TCTEdge>*  >
+template<> struct GenericGraphTraits<SVF::TCTNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::TCTNode,SVF::TCTEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for Value flow node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for Value flow node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::TCTNode *> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::TCTNode,SVF::TCTEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::TCTNode *> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::TCTNode,SVF::TCTEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::TCT*> : public GraphTraits<SVF::GenericGraph<SVF::TCTNode,SVF::TCTEdge>* >
+template<> struct GenericGraphTraits<SVF::TCT*> : public GenericGraphTraits<SVF::GenericGraph<SVF::TCTNode,SVF::TCTEdge>* >
 {
     typedef SVF::TCTNode *NodeRef;
 };

package/SVF-osx/include/SABER/SrcSnkSolver.h

@@ -46,14 +46,14 @@ class SrcSnkSolver
 
 public:
     ///Define the GTraits and node iterator
-    typedef llvm::GraphTraits<GraphType> GTraits;
+    typedef SVF::GraphTraits<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 llvm::GraphTraits<llvm::Inverse<GNODE *> > InvGTraits;
+    typedef SVF::GraphTraits<SVF::Inverse<GNODE *> > InvGTraits;
     typedef typename InvGTraits::ChildIteratorType inv_child_iterator;
 
     /// Define worklist

package/SVF-osx/include/SVF-LLVM/DCHG.h

@@ -455,23 +455,23 @@ private:
 
 } // End namespace SVF
 
-namespace llvm
+namespace SVF
 {
 /* !
- * GraphTraits specializations for generic graph algorithms.
+ * GenericGraphTraits specializations for generic graph algorithms.
  * Provide graph traits for traversing from a constraint node using standard graph traversals.
  */
-template<> struct GraphTraits<SVF::DCHNode*> : public GraphTraits<SVF::GenericNode<SVF::DCHNode,SVF::DCHEdge>*  >
+template<> struct GenericGraphTraits<SVF::DCHNode*> : public GenericGraphTraits<SVF::GenericNode<SVF::DCHNode,SVF::DCHEdge>*  >
 {
 };
 
-/// Inverse GraphTraits specializations for call graph node, it is used for inverse traversal.
+/// Inverse GenericGraphTraits specializations for call graph node, it is used for inverse traversal.
 template<>
-struct GraphTraits<Inverse<SVF::DCHNode*> > : public GraphTraits<Inverse<SVF::GenericNode<SVF::DCHNode,SVF::DCHEdge>* > >
+struct GenericGraphTraits<Inverse<SVF::DCHNode*> > : public GenericGraphTraits<Inverse<SVF::GenericNode<SVF::DCHNode,SVF::DCHEdge>* > >
 {
 };
 
-template<> struct GraphTraits<SVF::DCHGraph*> : public GraphTraits<SVF::GenericGraph<SVF::DCHNode,SVF::DCHEdge>* >
+template<> struct GenericGraphTraits<SVF::DCHGraph*> : public GenericGraphTraits<SVF::GenericGraph<SVF::DCHNode,SVF::DCHEdge>* >
 {
     typedef SVF::DCHNode *NodeRef;
 };

package/SVF-osx/include/SVF-LLVM/LLVMUtil.h

@@ -391,6 +391,11 @@ inline const Value* getGlobalRep(const Value* val)
     return val;
 }
 
+/// Check whether this value points-to a constant object
+bool isConstantObjSym(const SVFValue* val);
+
+/// Check whether this value points-to a constant object
+bool isConstantObjSym(const Value* val);
 
 // Dump Control Flow Graph of llvm function, with instructions
 void viewCFG(const Function* fun);

package/SVF-osx/include/SVF-LLVM/SymbolTableBuilder.h

@@ -57,9 +57,6 @@ public:
     /// Return size of this object based on LLVM value
     u32_t getObjSize(const Type* type);
 
-    /// Check whether this value points-to a constant object
-    bool isConstantObjSym(const Value* val);
-
 protected:
 
     /// collect the syms

package/SVF-osx/include/SVFIR/SVFValue.h

@@ -38,7 +38,7 @@ namespace SVF
 {
 
 /// LLVM Aliases and constants
-typedef llvm::GraphPrinter GraphPrinter;
+typedef SVF::GraphPrinter GraphPrinter;
 
 
 class SVFInstruction;
@@ -174,7 +174,6 @@ public:
 private:
     GNodeK kind;	///< used for classof
     bool ptrInUncalledFun;  ///< true if this pointer is in an uncalled function
-    bool has_name;          ///< true if this value has a name
     bool constDataOrAggData;    ///< true if this value is a ConstantData (e.g., numbers, string, floats) or a constantAggregate
 
 protected:
@@ -183,7 +182,7 @@ protected:
     std::string sourceLoc;  ///< Source code information of this value
     /// Constructor
     SVFValue(const std::string& val, const SVFType* ty, SVFValKind k): kind(k),
-        ptrInUncalledFun(false), has_name(false), constDataOrAggData(SVFConstData==k), type(ty),
+        ptrInUncalledFun(false), constDataOrAggData(SVFConstData==k), type(ty),
         name(val), sourceLoc("No source code Info")
     {
     }
@@ -197,10 +196,6 @@ protected:
     {
         ptrInUncalledFun = true;
     }
-    inline void setHasName()
-    {
-        has_name = true;
-    }
     ///@}
 public:
     SVFValue(void) = delete;
@@ -237,10 +232,6 @@ public:
     {
         return getKind() == SVFNullPtr;
     }
-    inline bool hasName() const
-    {
-        return has_name;
-    }
     inline virtual void setSourceLoc(const std::string& sourceCodeInfo)
     {
         sourceLoc = sourceCodeInfo;

package/SVF-osx/include/SVFIR/SVFVariables.h

@@ -289,7 +289,7 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value && value->hasName())
+        if (value)
             return value->getName();
         return "";
     }
@@ -343,7 +343,7 @@ public:
     /// Return name of a LLVM value
     virtual const std::string getValueName() const
     {
-        if (value && value->hasName())
+        if (value)
             return value->getName();
         return "";
     }
@@ -405,7 +405,7 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value && value->hasName())
+        if (value)
             return value->getName() + "_" + std::to_string(getConstantFieldIdx());
         return "offset_" + std::to_string(getConstantFieldIdx());
     }
@@ -490,7 +490,7 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value && value->hasName())
+        if (value)
             return value->getName() + "_" + std::to_string(ls.accumulateConstantFieldIdx());
         return "offset_" + std::to_string(ls.accumulateConstantFieldIdx());
     }
@@ -535,7 +535,7 @@ public:
     /// Return name of a LLVM value
     inline const std::string getValueName() const
     {
-        if (value && value->hasName())
+        if (value)
             return value->getName() + " (base object)";
         return " (base object)";
     }

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

@@ -46,14 +46,14 @@ class GraphReachSolver
 
 public:
     ///Define the GTraits and node iterator
-    typedef llvm::GraphTraits<GraphType> GTraits;
+    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 llvm::GraphTraits<llvm::Inverse<GNODE *> > InvGTraits;
+    typedef SVF::GenericGraphTraits<SVF::Inverse<GNODE *> > InvGTraits;
     typedef typename InvGTraits::ChildIteratorType inv_child_iterator;
 
     /// Define worklist

package/SVF-osx/include/Util/SCC.h

@@ -56,7 +56,7 @@ class SCCDetection
 
 private:
     ///Define the GTraits and node iterator for printing
-    typedef llvm::GraphTraits<GraphType> GTraits;
+    typedef SVF::GenericGraphTraits<GraphType> GTraits;
     typedef typename GTraits::NodeRef          GNODE;
     typedef typename GTraits::nodes_iterator node_iterator;
     typedef typename GTraits::ChildIteratorType child_iterator;

package/SVF-osx/include/Util/iterator.h

@@ -6,8 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ADT_ITERATOR_H
-#define LLVM_ADT_ITERATOR_H
+#ifndef UTIL_ITERATOR_H
+#define UTIL_ITERATOR_H
 
 #include "Util/iterator_range.h"
 #include <cstddef>
@@ -15,7 +15,7 @@
 #include <type_traits>
 #include <utility>
 
-namespace llvm
+namespace SVF
 {
 
 /// CRTP base class which implements the entire standard iterator facade
@@ -36,7 +36,7 @@ namespace llvm
 /// terms of addition of one. These aren't equivalent for all iterator
 /// categories, and respecting that adds a lot of complexity for little gain.
 ///
-/// Classes wishing to use `iterator_facade_base` should implement the following
+/// Classes wishing to use `iter_facade_base` should implement the following
 /// methods:
 ///
 /// Forward Iterators:
@@ -64,7 +64,7 @@ namespace llvm
 template <typename DerivedT, typename IteratorCategoryT, typename T,
           typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T *,
           typename ReferenceT = T &>
-class iterator_facade_base
+class iter_facade_base
 {
 public:
     using iterator_category = IteratorCategoryT;
@@ -89,7 +89,7 @@ protected:
     /// reference via a conversion operator.
     class ReferenceProxy
     {
-        friend iterator_facade_base;
+        friend iter_facade_base;
 
         DerivedT I;
 
@@ -105,7 +105,7 @@ protected:
 public:
     DerivedT operator+(DifferenceTypeT n) const
     {
-        static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
+        static_assert(std::is_base_of<iter_facade_base, DerivedT>::value,
                       "Must pass the derived type to this template!");
         static_assert(
             IsRandomAccess,
@@ -133,7 +133,7 @@ public:
 
     DerivedT &operator++()
     {
-        static_assert(std::is_base_of<iterator_facade_base, DerivedT>::value,
+        static_assert(std::is_base_of<iter_facade_base, DerivedT>::value,
                       "Must pass the derived type to this template!");
         return static_cast<DerivedT *>(this)->operator+=(1);
     }
@@ -232,20 +232,20 @@ template <
         std::is_same<T, typename std::iterator_traits<
                          WrappedIteratorT>::value_type>::value,
         typename std::iterator_traits<WrappedIteratorT>::reference, T &>>
-class iterator_adaptor_base
-    : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
+class iter_adaptor_base
+    : public iter_facade_base<DerivedT, IteratorCategoryT, T,
       DifferenceTypeT, PointerT, ReferenceT>
 {
-    using BaseT = typename iterator_adaptor_base::iterator_facade_base;
+    using BaseT = typename iter_adaptor_base::iter_facade_base;
 
 protected:
     WrappedIteratorT I;
 
-    iterator_adaptor_base() = default;
+    iter_adaptor_base() = default;
 
-    explicit iterator_adaptor_base(WrappedIteratorT u) : I(std::move(u))
+    explicit iter_adaptor_base(WrappedIteratorT u) : I(std::move(u))
     {
-        static_assert(std::is_base_of<iterator_adaptor_base, DerivedT>::value,
+        static_assert(std::is_base_of<iter_adaptor_base, DerivedT>::value,
                       "Must pass the derived type to this template!");
     }
 
@@ -300,13 +300,13 @@ public:
         return *static_cast<DerivedT *>(this);
     }
 
-    friend bool operator==(const iterator_adaptor_base &LHS,
-                           const iterator_adaptor_base &RHS)
+    friend bool operator==(const iter_adaptor_base &LHS,
+                           const iter_adaptor_base &RHS)
     {
         return LHS.I == RHS.I;
     }
-    friend bool operator<(const iterator_adaptor_base &LHS,
-                          const iterator_adaptor_base &RHS)
+    friend bool operator<(const iter_adaptor_base &LHS,
+                          const iter_adaptor_base &RHS)
     {
         static_assert(
             BaseT::IsRandomAccess,
@@ -327,21 +327,21 @@ public:
 /// which is implemented with some iterator over T*s:
 ///
 /// \code
-///   using iterator = pointee_iterator<SmallVectorImpl<T *>::iterator>;
+///   using iterator = pointee_iter<SmallVectorImpl<T *>::iterator>;
 /// \endcode
 template <typename WrappedIteratorT,
           typename T = std::remove_reference_t<decltype(
                       **std::declval<WrappedIteratorT>())>>
-struct pointee_iterator
-    : iterator_adaptor_base<
-      pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
+struct pointee_iter
+    : iter_adaptor_base<
+      pointee_iter<WrappedIteratorT, T>, WrappedIteratorT,
       typename std::iterator_traits<WrappedIteratorT>::iterator_category,
       T>
 {
-    pointee_iterator() = default;
+    pointee_iter() = default;
     template <typename U>
-    pointee_iterator(U &&u)
-        : pointee_iterator::iterator_adaptor_base(std::forward<U &&>(u)) {}
+    pointee_iter(U &&u)
+        : pointee_iter::iter_adaptor_base(std::forward<U &&>(u)) {}
 
     T &operator*() const
     {
@@ -351,10 +351,10 @@ struct pointee_iterator
 
 template <typename RangeT, typename WrappedIteratorT =
           decltype(std::begin(std::declval<RangeT>()))>
-iterator_range<pointee_iterator<WrappedIteratorT>>
-        make_pointee_range(RangeT &&Range)
+iter_range<pointee_iter<WrappedIteratorT>>
+                                        make_pointee_range(RangeT &&Range)
 {
-    using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
+    using PointeeIteratorT = pointee_iter<WrappedIteratorT>;
     return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
                       PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
 }
@@ -362,7 +362,7 @@ iterator_range<pointee_iterator<WrappedIteratorT>>
 template <typename WrappedIteratorT,
           typename T = decltype(&*std::declval<WrappedIteratorT>())>
 class pointer_iterator
-    : public iterator_adaptor_base<
+    : public iter_adaptor_base<
       pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
       typename std::iterator_traits<WrappedIteratorT>::iterator_category,
       T>
@@ -373,7 +373,7 @@ public:
     pointer_iterator() = default;
 
     explicit pointer_iterator(WrappedIteratorT u)
-        : pointer_iterator::iterator_adaptor_base(std::move(u)) {}
+        : pointer_iterator::iter_adaptor_base(std::move(u)) {}
 
     T &operator*()
     {
@@ -387,7 +387,7 @@ public:
 
 template <typename RangeT, typename WrappedIteratorT =
           decltype(std::begin(std::declval<RangeT>()))>
-iterator_range<pointer_iterator<WrappedIteratorT>>
+iter_range<pointer_iterator<WrappedIteratorT>>
         make_pointer_range(RangeT &&Range)
 {
     using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
@@ -400,7 +400,7 @@ template <typename WrappedIteratorT,
                       **std::declval<WrappedIteratorT>())>,
           typename T2 = std::add_pointer_t<T1>>
 using raw_pointer_iterator =
-    pointer_iterator<pointee_iterator<WrappedIteratorT, T1>, T2>;
+    pointer_iterator<pointee_iter<WrappedIteratorT, T1>, T2>;
 
 } // end namespace llvm
 

package/SVF-osx/include/Util/iterator_range.h

@@ -1,4 +1,4 @@
-//===- iterator_range.h - A range adaptor for iterators ---------*- C++ -*-===//
+//===- iter_range.h - A range adaptor for iterators ---------*- C++ -*-===//
 //
 // From the LLVM Project with some modifications, under the Apache License v2.0
 // with LLVM Exceptions. See https://llvm.org/LICENSE.txt for license information.
@@ -15,12 +15,12 @@
 ///
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_ADT_ITERATOR_RANGE_H
-#define LLVM_ADT_ITERATOR_RANGE_H
+#ifndef UTIL_ITERATOR_RANGE_H
+#define UTIL_ITERATOR_RANGE_H
 
 #include <utility>
 
-namespace llvm
+namespace SVF
 {
 
 /// A range adaptor for a pair of iterators.
@@ -28,7 +28,7 @@ namespace llvm
 /// This just wraps two iterators into a range-compatible interface. Nothing
 /// fancy at all.
 template <typename IteratorT>
-class iterator_range
+class iter_range
 {
     IteratorT begin_iterator, end_iterator;
 
@@ -36,10 +36,10 @@ public:
     //TODO: Add SFINAE to test that the Container's iterators match the range's
     //      iterators.
     template <typename Container>
-    iterator_range(Container &&c)
+    iter_range(Container &&c)
     //TODO: Consider ADL/non-member begin/end calls.
         : begin_iterator(c.begin()), end_iterator(c.end()) {}
-    iterator_range(IteratorT begin_iterator, IteratorT end_iterator)
+    iter_range(IteratorT begin_iterator, IteratorT end_iterator)
         : begin_iterator(std::move(begin_iterator)),
           end_iterator(std::move(end_iterator)) {}
 
@@ -61,14 +61,14 @@ public:
 ///
 /// This provides a bit of syntactic sugar to make using sub-ranges
 /// in for loops a bit easier. Analogous to std::make_pair().
-template <class T> iterator_range<T> make_range(T x, T y)
+template <class T> iter_range<T> make_range(T x, T y)
 {
-    return iterator_range<T>(std::move(x), std::move(y));
+    return iter_range<T>(std::move(x), std::move(y));
 }
 
-template <typename T> iterator_range<T> make_range(std::pair<T, T> p)
+template <typename T> iter_range<T> make_range(std::pair<T, T> p)
 {
-    return iterator_range<T>(std::move(p.first), std::move(p.second));
+    return iter_range<T>(std::move(p.first), std::move(p.second));
 }
 
 }

package/SVF-osx/include/WPA/WPASolver.h

@@ -45,7 +45,7 @@ class WPASolver
 
 public:
     ///Define the GTraits and node iterator for printing
-    typedef llvm::GraphTraits<GraphType> GTraits;
+    typedef SVF::GenericGraphTraits<GraphType> GTraits;
     typedef typename GTraits::NodeRef           GNODE;
     typedef typename GTraits::EdgeType          GEDGE;
     typedef typename GTraits::ChildIteratorType child_iterator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-lib",
-  "version": "1.0.1294",
+  "version": "1.0.1296",
   "description": "SVF's npm support",
   "main": "index.js",
   "scripts": {