svf-tools 1.0.1288 → 1.0.1289

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.1288",
+  "version": "1.0.1289",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {

package/svf/include/CFL/CFLAlias.h

@@ -44,7 +44,7 @@ class CFLAlias : public CFLBase
 public:
     typedef OrderedMap<const CallICFGNode*, NodeID> CallSite2DummyValPN;
 
-    CFLAlias(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFICI_WPA)
+    CFLAlias(SVFIR* ir) : CFLBase(ir, PTATY::CFLFICI_WPA)
     {
     }
 

package/svf/include/CFL/CFLBase.h

@@ -36,8 +36,10 @@
 #include "CFL/CFLGraphBuilder.h"
 #include "CFL/CFLGramGraphChecker.h"
 #include "MemoryModel/PointerAnalysis.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 #include "Graphs/ConsG.h"
 #include "Util/Options.h"
+#include "Util/PTAStat.h"
 #include "SVFIR/SVFType.h"
 
 namespace SVF
@@ -50,7 +52,7 @@ class CFLBase : public BVDataPTAImpl
 {
 
 public:
-    CFLBase(SVFIR* ir, PointerAnalysis::PTATY pty) : BVDataPTAImpl(ir, pty), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr)
+    CFLBase(SVFIR* ir, PTATY pty) : BVDataPTAImpl(ir, pty), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr)
     {
     }
 

package/svf/include/CFL/CFLVF.h

@@ -42,7 +42,7 @@ class CFLVF : public CFLBase
 {
 
 public:
-    CFLVF(SVFIR* ir) : CFLBase(ir, PointerAnalysis::CFLFSCS_WPA)
+    CFLVF(SVFIR* ir) : CFLBase(ir, PTATY::CFLFSCS_WPA)
     {
     }
 

package/svf/include/DDA/FlowDDA.h

@@ -58,7 +58,7 @@ public:
     typedef BVDataPTAImpl::CallEdgeMap	CallEdgeMap;
     typedef BVDataPTAImpl::FunctionSet	FunctionSet;
     /// Constructor
-    FlowDDA(SVFIR* _pag, DDAClient* client): BVDataPTAImpl(_pag, PointerAnalysis::FlowS_DDA),
+    FlowDDA(SVFIR* _pag, DDAClient* client): BVDataPTAImpl(_pag, PTATY::FlowS_DDA),
         DDAVFSolver<NodeID,PointsTo,LocDPItem>(),
         _client(client)
     {

package/svf/include/Graphs/GraphWriter.h

@@ -24,6 +24,7 @@
 
 #include "Graphs/GraphTraits.h"
 #include "Graphs/DOTGraphTraits.h"
+#include "Util/Options.h"
 #include <algorithm>
 #include <cstddef>
 #include <iterator>

package/svf/include/Graphs/SCC.h

@@ -41,6 +41,7 @@
 #define SCC_H_
 
 #include "SVFIR/SVFValue.h"	// for NodeBS
+#include "Util/WorkList.h"	// for NodeBS
 #include <limits.h>
 #include <stack>
 #include <map>

package/svf/include/MTA/MTA.h

@@ -36,6 +36,7 @@
 
 #include <set>
 #include <vector>
+#include "SVFIR/SVFIR.h"
 #include "SVFIR/SVFValue.h"
 
 namespace SVF

package/svf/include/MTA/TCT.h

@@ -30,6 +30,7 @@
 #ifndef TCTNodeDetector_H_
 #define TCTNodeDetector_H_
 
+#include "MemoryModel/PointerAnalysis.h"
 #include "Graphs/SCC.h"
 #include "Graphs/ThreadCallGraph.h"
 #include "Util/CxtStmt.h"

package/svf/include/MemoryModel/PTATY.h

@@ -0,0 +1,54 @@
+#ifndef PTATY_H
+#define PTATY_H
+
+namespace SVF {
+
+/// Pointer analysis type list
+enum PTATY
+{
+    // Whole program analysis
+    Andersen_BASE,		///< Base Andersen PTA
+    Andersen_WPA,		///< Andersen PTA
+    AndersenSCD_WPA,    ///< Selective cycle detection andersen-style WPA
+    AndersenSFR_WPA,    ///< Stride-based field representation
+    AndersenWaveDiff_WPA,	///< Diff wave propagation andersen-style WPA
+    Steensgaard_WPA,      ///< Steensgaard PTA
+    CSCallString_WPA,	///< Call string based context sensitive WPA
+    CSSummary_WPA,		///< Summary based context sensitive WPA
+    FSDATAFLOW_WPA,	///< Traditional Dataflow-based flow sensitive WPA
+    FSSPARSE_WPA,		///< Sparse flow sensitive WPA
+    VFS_WPA,		///< Versioned sparse flow-sensitive WPA
+    FSCS_WPA,			///< Flow-, context- sensitive WPA
+    CFLFICI_WPA,		///< Flow-, context-, insensitive CFL-reachability-based analysis
+    CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive CFL-reachability-based analysis
+    CFLFSCS_WPA,	///< Flow-, context-, CFL-reachability-based analysis
+    TypeCPP_WPA, ///<  Type-based analysis for C++
+
+    // Demand driven analysis
+    FieldS_DDA,		///< Field sensitive DDA
+    FlowS_DDA,		///< Flow sensitive DDA
+    PathS_DDA,		///< Guarded value-flow DDA
+    Cxt_DDA,		///< context sensitive DDA
+
+
+    Default_PTA		///< default pta without any analysis
+};
+
+/// Implementation type: BVDataPTAImpl or CondPTAImpl.
+enum PTAImplTy
+{
+    BaseImpl,   ///< Represents PointerAnalaysis.
+    BVDataImpl, ///< Represents BVDataPTAImpl.
+    CondImpl,   ///< Represents CondPTAImpl.
+};
+
+/// How the PTData used is implemented.
+enum PTBackingType
+{
+    Mutable,
+    Persistent,
+};
+
+}  // namespace SVF
+
+#endif // PTATY_H

package/svf/include/MemoryModel/PointerAnalysis.h

@@ -41,6 +41,7 @@
 #include "MemoryModel/MutablePointsToDS.h"
 #include "MemoryModel/PersistentPointsToDS.h"
 #include "MemoryModel/PointsTo.h"
+#include "MemoryModel/PTATY.h"
 #include "SVFIR/SVFIR.h"
 
 namespace SVF
@@ -57,45 +58,6 @@ class PointerAnalysis
 {
 
 public:
-    /// Pointer analysis type list
-    enum PTATY
-    {
-        // Whole program analysis
-        Andersen_BASE,		///< Base Andersen PTA
-        Andersen_WPA,		///< Andersen PTA
-        AndersenSCD_WPA,    ///< Selective cycle detection andersen-style WPA
-        AndersenSFR_WPA,    ///< Stride-based field representation
-        AndersenWaveDiff_WPA,	///< Diff wave propagation andersen-style WPA
-        Steensgaard_WPA,      ///< Steensgaard PTA
-        CSCallString_WPA,	///< Call string based context sensitive WPA
-        CSSummary_WPA,		///< Summary based context sensitive WPA
-        FSDATAFLOW_WPA,	///< Traditional Dataflow-based flow sensitive WPA
-        FSSPARSE_WPA,		///< Sparse flow sensitive WPA
-        VFS_WPA,		///< Versioned sparse flow-sensitive WPA
-        FSCS_WPA,			///< Flow-, context- sensitive WPA
-        CFLFICI_WPA,		///< Flow-, context-, insensitive CFL-reachability-based analysis
-        CFLFSCI_WPA,		///< Flow-insensitive, context-sensitive CFL-reachability-based analysis
-        CFLFSCS_WPA,	///< Flow-, context-, CFL-reachability-based analysis
-        TypeCPP_WPA, ///<  Type-based analysis for C++
-
-        // Demand driven analysis
-        FieldS_DDA,		///< Field sensitive DDA
-        FlowS_DDA,		///< Flow sensitive DDA
-        PathS_DDA,		///< Guarded value-flow DDA
-        Cxt_DDA,		///< context sensitive DDA
-
-
-        Default_PTA		///< default pta without any analysis
-    };
-
-    /// Implementation type: BVDataPTAImpl or CondPTAImpl.
-    enum PTAImplTy
-    {
-        BaseImpl,   ///< Represents PointerAnalaysis.
-        BVDataImpl, ///< Represents BVDataPTAImpl.
-        CondImpl,   ///< Represents CondPTAImpl.
-    };
-
     /// Indirect call edges type, map a callsite to a set of callees
     //@{
     typedef Set<const CallICFGNode*> CallSiteSet;
@@ -176,7 +138,7 @@ public:
     }
 
     /// Constructor
-    PointerAnalysis(SVFIR* pag, PTATY ty = Default_PTA, bool alias_check = true);
+    PointerAnalysis(SVFIR* pag, PTATY ty = PTATY::Default_PTA, bool alias_check = true);
 
     /// Type of pointer analysis
     inline PTATY getAnalysisTy() const

package/svf/include/MemoryModel/PointerAnalysisImpl.h

@@ -31,6 +31,7 @@
 #define INCLUDE_MEMORYMODEL_POINTERANALYSISIMPL_H_
 
 #include <Graphs/ConsG.h>
+#include "MemoryModel/PTATY.h"
 #include "MemoryModel/PointerAnalysis.h"
 
 namespace SVF
@@ -60,15 +61,8 @@ public:
     typedef PersistentIncDFPTData<NodeID, NodeSet, NodeID, PointsTo> PersIncDFPTDataTy;
     typedef PersistentVersionedPTData<NodeID, NodeSet, NodeID, PointsTo, VersionedVar, Set<VersionedVar>> PersVersionedPTDataTy;
 
-    /// How the PTData used is implemented.
-    enum PTBackingType
-    {
-        Mutable,
-        Persistent,
-    };
-
     /// Constructor
-    BVDataPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type, bool alias_check = true);
+    BVDataPTAImpl(SVFIR* pag, PTATY type, bool alias_check = true);
 
     /// Destructor
     ~BVDataPTAImpl() override = default;
@@ -80,7 +74,7 @@ public:
 
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return pta->getImplTy() == BVDataImpl;
+        return pta->getImplTy() == PTAImplTy::BVDataImpl;
     }
 
     /// Get points-to and reverse points-to
@@ -257,14 +251,14 @@ public:
     typedef Map<NodeID,CPtSet> PtrToCPtsMap;	 /// map a pointer to its conditional points-to set
 
     /// Constructor
-    CondPTAImpl(SVFIR* pag, PointerAnalysis::PTATY type) : PointerAnalysis(pag, type), normalized(false)
+    CondPTAImpl(SVFIR* pag, PTATY type) : PointerAnalysis(pag, type), normalized(false)
     {
-        if (type == PathS_DDA || type == Cxt_DDA)
+        if (type == PTATY::PathS_DDA || type == PTATY::Cxt_DDA)
             ptD = new MutPTDataTy();
         else
             assert(false && "no points-to data available");
 
-        ptaImplTy = CondImpl;
+        ptaImplTy = PTAImplTy::CondImpl;
     }
 
     /// Destructor
@@ -275,7 +269,7 @@ public:
 
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return pta->getImplTy() == CondImpl;
+        return pta->getImplTy() == PTAImplTy::CondImpl;
     }
 
     /// Release memory
@@ -527,7 +521,7 @@ public:
         expandFIObjs(pts2,cpts2);
         if (containBlackHoleNode(cpts1) || containBlackHoleNode(cpts2))
             return AliasResult::MayAlias;
-        else if(this->getAnalysisTy()==PathS_DDA && contains(cpts1,cpts2) && contains(cpts2,cpts1))
+        else if(this->getAnalysisTy() == PTATY::PathS_DDA && contains(cpts1,cpts2) && contains(cpts2,cpts1))
         {
             return AliasResult::MustAlias;
         }

package/svf/include/Util/Options.h

@@ -5,8 +5,8 @@
 
 #include <sstream>
 #include "Util/CommandLine.h"
-#include "Util/PTAStat.h"
-#include "MemoryModel/PointerAnalysisImpl.h"
+#include "Util/SVFStat.h"
+#include "MemoryModel/PTATY.h"
 #include "Util/NodeIDAllocator.h"
 
 namespace SVF
@@ -18,7 +18,7 @@ class Options
 public:
     Options(void) = delete;
 
-    static const OptionMap<enum PTAStat::ClockType> ClockType;
+    static const OptionMap<SVFStat::ClockType> ClockType;
 
     /// If set, only return the clock when getClk is called as getClk(true).
     /// Retrieving the clock is slow but it should be fine for a few calls.
@@ -63,7 +63,7 @@ public:
     static const Option<bool> PredictPtOcc;
 
     /// PTData type.
-    static const OptionMap<BVDataPTAImpl::PTBackingType> ptDataBacking;
+    static const OptionMap<PTBackingType> ptDataBacking;
 
     /// Time limit for the main phase (i.e., the actual solving) of FS analyses.
     static const Option<u32_t> FsTimeLimit;
@@ -87,7 +87,7 @@ public:
     static const Option<bool> PrintCPts;
     static const Option<bool> PrintQueryPts;
     static const Option<bool> WPANum;
-    static OptionMultiple<PointerAnalysis::PTATY> DDASelected;
+    static OptionMultiple<PTATY> DDASelected;
 
     // FlowDDA.cpp
     static const Option<u32_t> FlowBudget;
@@ -215,7 +215,7 @@ public:
     static const Option<bool> AnderSVFG;
     static const Option<bool> SABERFULLSVFG;
     static const Option<bool> PrintAliases;
-    static OptionMultiple<PointerAnalysis::PTATY> PASelected;
+    static OptionMultiple<PTATY> PASelected;
     static OptionMultiple<u32_t> AliasRule;
 
     // DOTGraphTraits
@@ -266,6 +266,9 @@ public:
 
     // float precision for symbolic abstraction
     static const Option<u32_t> AEPrecision;
+
+    // GraphWriter.h
+    static const Option<u32_t> MaxNodeLabelLength;
 };
 }  // namespace SVF
 

package/svf/include/Util/SVFStat.h

@@ -30,6 +30,8 @@
 #ifndef SVF_SVFSTAT_H
 #define SVF_SVFSTAT_H
 
+#include "MemoryModel/PointsTo.h"
+
 namespace SVF
 {
 
@@ -45,7 +47,7 @@ public:
 
     typedef OrderedMap<std::string, double> TIMEStatMap;
 
-    enum ClockType
+    enum class ClockType
     {
         Wall,
         CPU,

package/svf/include/WPA/Andersen.h

@@ -35,6 +35,7 @@
 #ifndef INCLUDE_WPA_ANDERSEN_H_
 #define INCLUDE_WPA_ANDERSEN_H_
 
+#include "MemoryModel/PTATY.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "WPA/WPAStat.h"
 #include "WPA/WPASolver.h"
@@ -61,7 +62,7 @@ public:
 public:
 
     /// Constructor
-    AndersenBase(SVFIR* _pag, PTATY type = Andersen_BASE, bool alias_check = true)
+    AndersenBase(SVFIR* _pag, PTATY type = PTATY::Andersen_BASE, bool alias_check = true)
         :  BVDataPTAImpl(_pag, type, alias_check), consCG(nullptr)
     {
         iterationForPrintStat = OnTheFlyIterBudgetForStat;
@@ -107,13 +108,13 @@ public:
     }
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return ( pta->getAnalysisTy() == Andersen_BASE
-                 || pta->getAnalysisTy() == Andersen_WPA
-                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                 || pta->getAnalysisTy() == AndersenSCD_WPA
-                 || pta->getAnalysisTy() == AndersenSFR_WPA
-                 || pta->getAnalysisTy() == TypeCPP_WPA
-                 || pta->getAnalysisTy() == Steensgaard_WPA);
+        return ( pta->getAnalysisTy() == PTATY::Andersen_BASE
+                 || pta->getAnalysisTy() == PTATY::Andersen_WPA
+                 || pta->getAnalysisTy() == PTATY::AndersenWaveDiff_WPA
+                 || pta->getAnalysisTy() == PTATY::AndersenSCD_WPA
+                 || pta->getAnalysisTy() == PTATY::AndersenSFR_WPA
+                 || pta->getAnalysisTy() == PTATY::TypeCPP_WPA
+                 || pta->getAnalysisTy() == PTATY::Steensgaard_WPA);
     }
     //@}
 
@@ -193,7 +194,7 @@ public:
     typedef SCCDetection<ConstraintGraph*> CGSCC;
 
     /// Constructor
-    Andersen(SVFIR* _pag, PTATY type = Andersen_WPA, bool alias_check = true)
+    Andersen(SVFIR* _pag, PTATY type = PTATY::Andersen_WPA, bool alias_check = true)
         :  AndersenBase(_pag, type, alias_check)
     {
     }
@@ -227,10 +228,10 @@ public:
     }
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return (pta->getAnalysisTy() == Andersen_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                || pta->getAnalysisTy() == AndersenSCD_WPA
-                || pta->getAnalysisTy() == AndersenSFR_WPA);
+        return (pta->getAnalysisTy() == PTATY::Andersen_WPA
+                || pta->getAnalysisTy() == PTATY::AndersenWaveDiff_WPA
+                || pta->getAnalysisTy() == PTATY::AndersenSCD_WPA
+                || pta->getAnalysisTy() == PTATY::AndersenSFR_WPA);
     }
     //@}
 
@@ -401,14 +402,14 @@ private:
     static AndersenWaveDiff* diffWave; // static instance
 
 public:
-    AndersenWaveDiff(SVFIR* _pag, PTATY type = AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
+    AndersenWaveDiff(SVFIR* _pag, PTATY type = PTATY::AndersenWaveDiff_WPA, bool alias_check = true): Andersen(_pag, type, alias_check) {}
 
     /// Create an singleton instance directly instead of invoking llvm pass manager
     static AndersenWaveDiff* createAndersenWaveDiff(SVFIR* _pag)
     {
         if(diffWave==nullptr)
         {
-            diffWave = new AndersenWaveDiff(_pag, AndersenWaveDiff_WPA, false);
+            diffWave = new AndersenWaveDiff(_pag, PTATY::AndersenWaveDiff_WPA, false);
             diffWave->analyze();
             return diffWave;
         }

package/svf/include/WPA/AndersenPWC.h

@@ -33,6 +33,7 @@
 
 #include "WPA/Andersen.h"
 #include "WPA/CSC.h"
+#include "MemoryModel/PTATY.h"
 #include "MemoryModel/PointsTo.h"
 
 namespace SVF
@@ -52,7 +53,7 @@ protected:
     NodeToNodeMap pwcReps;
 
 public:
-    AndersenSCD(SVFIR* _pag, PTATY type = AndersenSCD_WPA) :
+    AndersenSCD(SVFIR* _pag, PTATY type = PTATY::AndersenSCD_WPA) :
         Andersen(_pag,type)
     {
     }
@@ -114,7 +115,7 @@ private:
     FieldReps fieldReps;
 
 public:
-    AndersenSFR(SVFIR* _pag, PTATY type = AndersenSFR_WPA) :
+    AndersenSFR(SVFIR* _pag, PTATY type = PTATY::AndersenSFR_WPA) :
         AndersenSCD(_pag, type), csc(nullptr)
     {
     }

package/svf/include/WPA/FlowSensitive.h

@@ -57,7 +57,7 @@ public:
     typedef BVDataPTAImpl::MutDFPTDataTy::PtsMap PtsMap;
 
     /// Constructor
-    explicit FlowSensitive(SVFIR* _pag, PTATY type = FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
+    explicit FlowSensitive(SVFIR* _pag, PTATY type = PTATY::FSSPARSE_WPA) : WPASVFGFSSolver(), BVDataPTAImpl(_pag, type)
     {
         svfg = nullptr;
         solveTime = sccTime = processTime = propagationTime = updateTime = 0;
@@ -126,7 +126,7 @@ public:
     }
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return pta->getAnalysisTy() == FSSPARSE_WPA;
+        return pta->getAnalysisTy() == PTATY::FSSPARSE_WPA;
     }
     //@}
 

package/svf/include/WPA/VersionedFlowSensitive.h

@@ -18,6 +18,7 @@
 #include "MSSA/SVFGBuilder.h"
 #include "WPA/FlowSensitive.h"
 #include "WPA/WPAFSSolver.h"
+#include "MemoryModel/PTATY.h"
 #include "MemoryModel/PointsTo.h"
 
 namespace SVF
@@ -50,7 +51,7 @@ public:
     static VersionedVar atKey(NodeID, Version);
 
     /// Constructor
-    VersionedFlowSensitive(SVFIR *_pag, PTATY type = VFS_WPA);
+    VersionedFlowSensitive(SVFIR *_pag, PTATY type = PTATY::VFS_WPA);
 
     /// Initialize analysis
     virtual void initialize() override;
@@ -72,7 +73,7 @@ public:
     }
     static inline bool classof(const PointerAnalysis *pta)
     {
-        return pta->getAnalysisTy() == VFS_WPA;
+        return pta->getAnalysisTy() == PTATY::VFS_WPA;
     }
     //@}
 

package/svf/lib/AE/Core/AbstractState.cpp

@@ -27,6 +27,7 @@
  *
  */
 
+#include <iomanip>
 #include "AE/Core/AbstractState.h"
 #include "SVFIR/SVFIR.h"
 #include "Util/SVFUtil.h"
@@ -341,4 +342,4 @@ bool AbstractState::geqVarToValMap(const VarToAbsValMap&lhs, const VarToAbsValMa
             return false;
     }
     return true;
-}
+}

package/svf/lib/DDA/ContextDDA.cpp

@@ -40,7 +40,7 @@ using namespace SVFUtil;
  * Constructor
  */
 ContextDDA::ContextDDA(SVFIR* _pag,  DDAClient* client)
-    : CondPTAImpl<ContextCond>(_pag, PointerAnalysis::Cxt_DDA),DDAVFSolver<CxtVar,CxtPtSet,CxtLocDPItem>(),
+    : CondPTAImpl<ContextCond>(_pag, PTATY::Cxt_DDA),DDAVFSolver<CxtVar,CxtPtSet,CxtLocDPItem>(),
       _client(client)
 {
     flowDDA = new FlowDDA(_pag, client);

package/svf/lib/DDA/DDAPass.cpp

@@ -59,10 +59,9 @@ void DDAPass::runOnModule(SVFIR* pag)
 
     selectClient();
 
-    for (u32_t i = PointerAnalysis::FlowS_DDA;
-            i < PointerAnalysis::Default_PTA; i++)
+    for (u32_t i = PTATY::FlowS_DDA; i < PTATY::Default_PTA; i++)
     {
-        PointerAnalysis::PTATY iPtTy = static_cast<PointerAnalysis::PTATY>(i);
+        PTATY iPtTy = static_cast<PTATY>(i);
         if (Options::DDASelected(iPtTy))
             runPointerAnalysis(pag, i);
     }
@@ -114,12 +113,12 @@ void DDAPass::runPointerAnalysis(SVFIR* pag, u32_t kind)
     /// Initialize pointer analysis.
     switch (kind)
     {
-    case PointerAnalysis::Cxt_DDA:
+    case PTATY::Cxt_DDA:
     {
         _pta = std::make_unique<ContextDDA>(pag, _client);
         break;
     }
-    case PointerAnalysis::FlowS_DDA:
+    case PTATY::FlowS_DDA:
     {
         _pta = std::make_unique<FlowDDA>(pag, _client);
         break;

package/svf/lib/Graphs/CallGraph.cpp

@@ -28,6 +28,8 @@
  *      Author: Yulei Sui
  */
 
+#include <functional>
+
 #include "Graphs/CallGraph.h"
 #include "SVFIR/SVFIR.h"
 #include "Util/Options.h"

package/svf/lib/Graphs/SVFG.cpp

@@ -852,10 +852,11 @@ struct DOTGraphTraits<SVFG*> : public DOTGraphTraits<SVFIR*>
 
     std::string getNodeLabel(NodeType *node, SVFG *graph)
     {
+        std::string cool = std::string(240, '-');
         if (isSimple())
-            return getSimpleNodeLabel(node, graph);
+            return cool + getSimpleNodeLabel(node, graph);
         else
-            return getCompleteNodeLabel(node, graph);
+            return cool + getCompleteNodeLabel(node, graph);
     }
 
     /// Return label of a VFG node without MemSSA information

package/svf/lib/Graphs/VFG.cpp

@@ -27,10 +27,11 @@
  *      Author: Yulei Sui
  */
 
-
+#include "MemoryModel/PointerAnalysis.h"
 #include <Graphs/SVFGNode.h>
-#include "Util/Options.h"
+#include "Graphs/CallGraph.h"
 #include "Graphs/VFG.h"
+#include "Util/Options.h"
 #include "Util/SVFUtil.h"
 
 using namespace SVF;
@@ -928,8 +929,8 @@ void VFG::view()
 void VFG::updateCallGraph(PointerAnalysis* pta)
 {
     VFGEdgeSetTy vfEdgesAtIndCallSite;
-    PointerAnalysis::CallEdgeMap::const_iterator iter = pta->getIndCallMap().begin();
-    PointerAnalysis::CallEdgeMap::const_iterator eiter = pta->getIndCallMap().end();
+    CallGraph::CallEdgeMap::const_iterator iter = pta->getIndCallMap().begin();
+    CallGraph::CallEdgeMap::const_iterator eiter = pta->getIndCallMap().end();
     for (; iter != eiter; iter++)
     {
         const CallICFGNode* newcs = iter->first;

package/svf/lib/MSSA/MemRegion.cpp

@@ -28,6 +28,7 @@
  */
 
 #include "Util/Options.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 #include "MSSA/MemRegion.h"
 #include "MSSA/MSSAMuChi.h"
 #include "Graphs/CallGraph.h"

package/svf/lib/MSSA/MemSSA.cpp

@@ -28,6 +28,7 @@
  */
 
 #include "Util/Options.h"
+#include "MemoryModel/PointerAnalysisImpl.h"
 #include "MSSA/MemPartition.h"
 #include "MSSA/MemSSA.h"
 #include "Graphs/SVFGStat.h"
@@ -48,7 +49,7 @@ double MemSSA::timeOfSSARenaming  = 0;	///< Time for SSA rename
 MemSSA::MemSSA(BVDataPTAImpl* p, bool ptrOnlyMSSA)
 {
     pta = p;
-    assert((pta->getAnalysisTy()!=PointerAnalysis::Default_PTA)
+    assert((pta->getAnalysisTy() != PTATY::Default_PTA)
            && "please specify a pointer analysis");
 
     if (Options::MemPar() == MemPartition::Distinct)

package/svf/lib/MemoryModel/AccessPath.cpp

@@ -29,8 +29,10 @@
  *
  */
 
-#include "Util/Options.h"
 #include "MemoryModel/AccessPath.h"
+#include "SVFIR/SVFIR.h"
+#include "SVFIR/SVFVariables.h"
+#include "Util/Options.h"
 #include "Util/SVFUtil.h"
 
 using namespace SVF;