svf-lib 1.0.1341 → 1.0.1343

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

@@ -0,0 +1,527 @@
+#ifndef COMMANDLINE_H_
+#define COMMANDLINE_H_
+
+#include <algorithm>
+#include <cassert>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <limits>
+#include <map>
+#include <vector>
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+
+typedef unsigned u32_t;
+
+class OptionBase
+{
+protected:
+    /// Name/description pairs.
+    typedef std::pair<std::string, std::string> PossibilityDescription;
+    typedef std::vector<std::pair<std::string, std::string>> PossibilityDescriptions;
+
+    /// Value/name/description tuples. If [1] is the value on the commandline for an option, we'd
+    /// set the value for the associated Option to [0].
+    template <typename T>
+    using OptionPossibility = std::tuple<T, std::string, std::string>;
+
+protected:
+    OptionBase(std::string name, std::string description)
+        : OptionBase(name, description, {})
+    {
+    }
+
+    OptionBase(std::string name, std::string description, PossibilityDescriptions possibilityDescriptions)
+        : name(name), description(description), possibilityDescriptions(possibilityDescriptions)
+    {
+        assert(name[0] != '-' && "OptionBase: name starts with '-'");
+        assert(!isHelpName(name) && "OptionBase: reserved help name");
+        assert(getOptionsMap().find(name) == getOptionsMap().end() && "OptionBase: duplicate option");
+
+        // Types with empty names (i.e., OptionMultiple) can handle things themselves.
+        if (!name.empty())
+        {
+            // Standard name=value option.
+            getOptionsMap()[name] = this;
+        }
+    }
+
+    /// From a given string, set the value of this option.
+    virtual bool parseAndSetValue(const std::string value) = 0;
+
+    /// Whether this option represents a boolean. Important as such
+    /// arguments don't require a value.
+    virtual bool isBool(void) const
+    {
+        return false;
+    }
+
+    /// Whether this option is an OptionMultiple.
+    virtual bool isMultiple(void) const
+    {
+        return false;
+    }
+
+    /// Can this option be set?
+    virtual bool canSet(void) const = 0;
+
+public:
+    /// Parse all constructed OptionBase children, returning positional arguments
+    /// in the order they appeared.
+    static std::vector<std::string> parseOptions(int argc, char *argv[], std::string description, std::string callFormat)
+    {
+        const std::string usage = buildUsage(description, std::string(argv[0]), callFormat);
+
+        std::vector<std::string> positionalArguments;
+
+        for (int i = 1; i < argc; ++i)
+        {
+            std::string arg(argv[i]);
+            if (arg.empty()) continue;
+            if (arg[0] != '-')
+            {
+                // Positional argument. NOT a value to another argument because we
+                // "skip" over evaluating those without the corresponding argument.
+                positionalArguments.push_back(arg);
+                continue;
+            }
+
+            // Chop off '-'.
+            arg = arg.substr(1);
+
+            std::string argName;
+            std::string argValue;
+            OptionBase *opt = nullptr;
+
+            size_t equalsSign = arg.find('=');
+            if (equalsSign != std::string::npos)
+            {
+                // Argument has an equal sign, i.e. argName=argValue
+                argName = arg.substr(0, equalsSign);
+                if (isHelpName(argName)) usageAndExit(usage, false);
+
+                opt = getOption(argName);
+                if (opt == nullptr)
+                {
+                    std::cerr << "Unknown option: " << argName << std::endl;
+                    usageAndExit(usage, true);
+                }
+
+                argValue = arg.substr(equalsSign + 1);
+            }
+            else
+            {
+                argName = arg;
+                if (isHelpName(argName)) usageAndExit(usage, false);
+
+                opt = getOption(argName);
+                if (opt == nullptr)
+                {
+                    std::cerr << "Unknown option: " << argName << std::endl;
+                    usageAndExit(usage, true);
+                }
+
+                // No equals sign means we may need next argument.
+                if (opt->isBool())
+                {
+                    // Booleans do not accept -arg true/-arg false.
+                    // They must be -arg=true/-arg=false.
+                    argValue = "true";
+                }
+                else if (opt->isMultiple())
+                {
+                    // Name is the value and will be converted to an enum.
+                    argValue = argName;
+                }
+                else if (i + 1 < argc)
+                {
+                    // On iteration, we'll skip the value.
+                    ++i;
+                    argValue = std::string(argv[i]);
+                }
+                else
+                {
+                    std::cerr << "Expected value for: " << argName << std::endl;
+                    usageAndExit(usage, true);
+                }
+            }
+
+            if (!opt->canSet())
+            {
+                std::cerr << "Unable to set: " << argName << "; check for duplicates" << std::endl;
+                usageAndExit(usage, true);
+            }
+
+            bool valueSet = opt->parseAndSetValue(argValue);
+            if (!valueSet)
+            {
+                std::cerr << "Bad value for: " << argName << std::endl;
+                usageAndExit(usage, true);
+            }
+        }
+
+        return positionalArguments;
+    }
+
+private:
+    /// Sets the usage member to a usage string, built from the static list of options.
+    /// argv0 is argv[0] and callFormat is how the command should be used, minus the command
+    /// name (e.g. "[options] <input-bitcode...>".
+    static std::string buildUsage(
+        const std::string description, const std::string argv0, const std::string callFormat
+    )
+    {
+        // Determine longest option to split into two columns: options and descriptions.
+        unsigned longest = 0;
+        for (const std::pair<std::string, OptionBase *> nopt : getOptionsMap())
+        {
+            const std::string name = std::get<0>(nopt);
+            const OptionBase *option = std::get<1>(nopt);
+            if (option->isMultiple())
+            {
+                // For Multiple, description goes in left column.
+                if (option->description.length() > longest) longest = option->description.length();
+            }
+            else
+            {
+                if (name.length() > longest) longest = name.length();
+            }
+
+            for (const PossibilityDescription &pd : option->possibilityDescriptions)
+            {
+                const std::string possibility = std::get<0>(pd);
+                if (possibility.length() + 3 > longest) longest = possibility.length() + 3;
+            }
+        }
+
+        std::stringstream ss;
+
+        ss << description << std::endl << std::endl;
+
+        ss << "USAGE:" << std::endl;
+        ss << "  " << argv0 << " " << callFormat << std::endl;
+        ss << std::endl;
+
+        ss << "OPTIONS:" << std::endl;
+
+        // Required as we have OptionMultiples doing a many-to-one in options.
+        std::unordered_set<const OptionBase *> handled;
+        for (const std::pair<std::string, OptionBase *> nopt : getOptionsMap())
+        {
+            const std::string name = std::get<0>(nopt);
+            const OptionBase *option = std::get<1>(nopt);
+            if (handled.find(option) != handled.end()) continue;
+            handled.insert(option);
+
+            if (option->isMultiple())
+            {
+                // description
+                //   -name1      - description
+                //   -name2      - description
+                //   ...
+                ss << "  " << option->description << std::endl;
+                for (const PossibilityDescription &pd : option->possibilityDescriptions)
+                {
+                    const std::string possibility = std::get<0>(pd);
+                    const std::string description = std::get<1>(pd);
+                    ss << "    -" << possibility << std::string(longest - possibility.length() + 2, ' ');
+                    ss << "- " << description << std::endl;
+                }
+            }
+            else
+            {
+                // name  - description
+                // or
+                // name     - description
+                //   =opt1    - description
+                //   =opt2    - description
+                //   ...
+                ss << "  -" << name << std::string(longest - name.length() + 2, ' ');
+                ss << "- " << option->description << std::endl;
+                for (const PossibilityDescription &pd : option->possibilityDescriptions)
+                {
+                    const std::string possibility = std::get<0>(pd);
+                    const std::string description = std::get<1>(pd);
+                    ss << "    =" << possibility << std::string(longest - possibility.length() + 2, ' ');
+                    ss << "- " << description << std::endl;
+                }
+            }
+        }
+
+        // Help message.
+        ss << std::endl;
+        ss << "  -help" << std::string(longest - 4 + 2, ' ') << "- show usage and exit" << std::endl;
+        ss << "  -h" << std::string(longest - 1 + 2, ' ') << "- show usage and exit" << std::endl;
+
+        // How to set boolean options.
+        ss << std::endl;
+        ss << "Note: for boolean options, -name true and -name false are invalid." << std::endl;
+        ss << "      Use -name, -name=true, or -name=false." << std::endl;
+
+        return ss.str();
+    }
+
+    /// Find option based on name in options map. Returns nullptr if not found.
+    static OptionBase *getOption(const std::string optName)
+    {
+        auto optIt = getOptionsMap().find(optName);
+        if (optIt == getOptionsMap().end()) return nullptr;
+        else return optIt->second;
+    }
+
+    /// Print usage and exit. If error is set, print to stderr and exits with code 1.
+    static void usageAndExit(const std::string usage, bool error)
+    {
+        if (error) std::cerr << usage;
+        else std::cout << usage;
+        std::exit(error ? 1 : 0);
+    }
+
+    /// Returns whether name is one of the reserved help options.
+    static bool isHelpName(const std::string name)
+    {
+        static std::vector<std::string> helpNames = {"help", "h", "-help"};
+        return std::find(helpNames.begin(), helpNames.end(), name) != helpNames.end();
+    }
+
+protected:
+    // Return the name/description part of OptionsPossibilities (second and third fields).
+    template<typename T>
+    static PossibilityDescriptions extractPossibilityDescriptions(const std::vector<OptionPossibility<T>> possibilities)
+    {
+        PossibilityDescriptions possibilityDescriptions;
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            possibilityDescriptions.push_back(std::make_pair(std::get<1>(op), std::get<2>(op)));
+        }
+
+        return possibilityDescriptions;
+    }
+
+    /// Not unordered map so we can have sorted names when building the usage string.
+    /// Map of option names to their object.
+    static std::map<std::string, OptionBase *> &getOptionsMap(void)
+    {
+        // Not static member to avoid initialisation order problems.
+        static std::map<std::string, OptionBase *> options;
+        return options;
+    }
+
+
+protected:
+    std::string name;
+    std::string description;
+    /// For when we have possibilities like in an OptionMap.
+    PossibilityDescriptions possibilityDescriptions;
+};
+
+/// General -name=value options.
+/// Retrieve value by Opt().
+template <typename T>
+class Option : public OptionBase
+{
+public:
+    Option(std::string name, std::string description, T init)
+        : OptionBase(name, description), isExplicitlySet(false), value(init)
+    {
+        assert(!name.empty() && "Option: empty option name given");
+    }
+
+    virtual bool canSet(void) const override
+    {
+        // Don't allow duplicates.
+        return !isExplicitlySet;
+    }
+
+    virtual bool parseAndSetValue(const std::string s) override
+    {
+        isExplicitlySet = fromString(s, value);
+        return isExplicitlySet;
+    }
+
+    virtual bool isBool(void) const override
+    {
+        return std::is_same<T, bool>::value;
+    }
+
+    void setValue(T v)
+    {
+        value = v;
+    }
+
+    T operator()(void) const
+    {
+        return value;
+    }
+
+private:
+    // Convert string to boolean, returning whether we succeeded.
+    static bool fromString(const std::string s, bool &value)
+    {
+        if (s == "true") value = true;
+        else if (s == "false") value = false;
+        else return false;
+        return true;
+    }
+
+    // Convert string to string, always succeeds.
+    static bool fromString(const std::string s, std::string &value)
+    {
+        value = s;
+        return true;
+    }
+
+    // Convert string to u32_t, returning whether we succeeded.
+    static bool fromString(const std::string s, u32_t &value)
+    {
+        // We won't allow anything except [0-9]+.
+        if (s.empty()) return false;
+        for (char c : s)
+        {
+            if (!(c >= '0' && c <= '9')) return false;
+        }
+
+        // Use strtoul because we're not using exceptions.
+        assert(sizeof(unsigned long) >= sizeof(u32_t));
+        const unsigned long sv = std::strtoul(s.c_str(), nullptr, 10);
+
+        // Out of range according to strtoul, or according to us compared to u32_t.
+        if (errno == ERANGE || sv > std::numeric_limits<u32_t>::max()) return false;
+        value = sv;
+        return true;
+    }
+
+private:
+    bool isExplicitlySet;
+    T value;
+};
+
+/// Option allowing a limited range of values, probably corresponding to an enum.
+/// Opt() gives the value.
+template <typename T>
+class OptionMap : public OptionBase
+{
+public:
+    typedef std::vector<OptionPossibility<T>> OptionPossibilities;
+
+    OptionMap(std::string name, std::string description, T init, OptionPossibilities possibilities)
+        : OptionBase(name, description, extractPossibilityDescriptions(possibilities)),
+          isExplicitlySet(false), value(init), possibilities(possibilities)
+    {
+        assert(!name.empty() && "OptionMap: empty option name given");
+    }
+
+    virtual bool canSet(void) const override
+    {
+        return !isExplicitlySet;
+    }
+
+    virtual bool parseAndSetValue(const std::string s) override
+    {
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            // Check if the given string is a valid one.
+            if (s == std::get<1>(op))
+            {
+                // What that string maps to.
+                value = std::get<0>(op);
+                isExplicitlySet = true;
+                break;
+            }
+        }
+
+        return isExplicitlySet;
+    }
+
+    T operator()(void) const
+    {
+        return value;
+    }
+
+private:
+    bool isExplicitlySet;
+    T value;
+    OptionPossibilities possibilities;
+};
+
+/// Options which form a kind of bit set. There are multiple names and n of them can be set.
+/// Opt(v) tests whether v had been set, aborting if v is invalid.
+template <typename T>
+class OptionMultiple : public OptionBase
+{
+public:
+    typedef std::vector<OptionPossibility<T>> OptionPossibilities;
+
+    OptionMultiple(std::string description, OptionPossibilities possibilities)
+        : OptionBase("", description, extractPossibilityDescriptions(possibilities)), possibilities(possibilities)
+    {
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            optionValues[std::get<0>(op)] = false;
+        }
+
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            std::string possibilityName = std::get<1>(op);
+            getOptionsMap()[possibilityName] = this;
+        }
+    }
+
+    virtual bool canSet(void) const override
+    {
+        return true;
+    }
+
+    virtual bool parseAndSetValue(const std::string s) override
+    {
+        // Like in OptionMap basically, except we can have many values.
+        for (const OptionPossibility<T> &op : possibilities)
+        {
+            if (s == std::get<1>(op))
+            {
+                optionValues[std::get<0>(op)] = true;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    virtual bool isMultiple(void) const override
+    {
+        return true;
+    }
+
+    /// If the bitset is empty.
+    bool nothingSet(void) const
+    {
+        for (const std::pair<T, bool> tb : optionValues)
+        {
+            if (tb.second) return false;
+        }
+
+        return true;
+    }
+
+    /// Returns whether the value v had been set as an option.
+    bool operator()(const T v) const
+    {
+        typename std::unordered_map<T, bool>::const_iterator ovIt = optionValues.find(v);
+        // TODO: disabled as we check for "invalid" values in some places.
+        // assert(ovIt != optionValues.end() && "OptionMultiple: bad value checked");
+        if (ovIt == optionValues.end()) return false;
+        return ovIt->second;
+    }
+
+private:
+    /// Is the option set? Use a map rather than a set because it's now easier in one
+    /// DS to determine whether something is 1) valid, and 2) set.
+    std::unordered_map<T, bool> optionValues;
+    OptionPossibilities possibilities;
+};
+
+#endif  /* COMMANDLINE_H_ */

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

@@ -5,12 +5,12 @@
 
 #include <sstream>
 #include "FastCluster/fastcluster.h"
+#include "Util/CommandLine.h"
 #include "Util/PTAStat.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "Util/NodeIDAllocator.h"
 #include "MSSA/MemSSA.h"
 #include "WPA/WPAPass.h"
-#include <llvm/Support/CommandLine.h>	// for command line options
 
 namespace SVF
 {
@@ -21,244 +21,244 @@ class Options
 public:
     Options(void) = delete;
 
-    static const llvm::cl::opt<enum PTAStat::ClockType> ClockType;
+    static const OptionMap<enum PTAStat::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.
     /// This is good for benchmarking when we don't need to know how long processLoad
     /// takes, for example (many calls), but want to know things like total solve time.
     /// Should be used only to affect getClk, not CLOCK_IN_MS.
-    static const llvm::cl::opt<bool> MarkedClocksOnly;
+    static const Option<bool> MarkedClocksOnly;
 
     /// Allocation strategy to be used by the node ID allocator.
     /// Currently dense, seq, or debug.
-    static const llvm::cl::opt<SVF::NodeIDAllocator::Strategy> NodeAllocStrat;
+    static const OptionMap<SVF::NodeIDAllocator::Strategy> NodeAllocStrat;
 
     /// Maximum number of field derivations for an object.
-    static const llvm::cl::opt<unsigned> MaxFieldLimit;
+    static const Option<u32_t> MaxFieldLimit;
 
     /// Whether to stage Andersen's with Steensgaard and cluster based on that data.
-    static const llvm::cl::opt<bool> ClusterAnder;
+    static const Option<bool> ClusterAnder;
 
     /// Whether to cluster FS or VFS with the auxiliary Andersen's.
-    static const llvm::cl::opt<bool> ClusterFs;
+    static const Option<bool> ClusterFs;
 
     /// Use an explicitly plain mapping with flow-sensitive (not null).
-    static const llvm::cl::opt<bool> PlainMappingFs;
+    static const Option<bool> PlainMappingFs;
 
     /// Type of points-to set to use for all analyses.
-    static const llvm::cl::opt<PointsTo::Type> PtType;
+    static const OptionMap<PointsTo::Type> PtType;
 
     /// Clustering method for ClusterFs/ClusterAnder.
     /// TODO: we can separate it into two options, and make Clusterer::cluster take in a method
     ///       argument rather than plugging Options::ClusterMethod *inside* Clusterer::cluster
     ///       directly, but it seems we will always want single anyway, and this is for testing.
-    static const llvm::cl::opt<enum hclust_fast_methods> ClusterMethod;
+    static const OptionMap<enum hclust_fast_methods> ClusterMethod;
 
     /// Cluster partitions separately.
-    static const llvm::cl::opt<bool> RegionedClustering;
+    static const Option<bool> RegionedClustering;
 
     /// Align identifiers in each region to a word.
-    static const llvm::cl::opt<bool> RegionAlign;
+    static const Option<bool> RegionAlign;
 
     /// Predict occurences of points-to sets in the staged points-to set to
     /// weigh more common points-to sets as more important.
-    static const llvm::cl::opt<bool> PredictPtOcc;
+    static const Option<bool> PredictPtOcc;
 
     /// PTData type.
-    static const llvm::cl::opt<BVDataPTAImpl::PTBackingType> ptDataBacking;
+    static const OptionMap<BVDataPTAImpl::PTBackingType> ptDataBacking;
 
     /// Time limit for the main phase (i.e., the actual solving) of FS analyses.
-    static const llvm::cl::opt<unsigned> FsTimeLimit;
+    static const Option<u32_t> FsTimeLimit;
 
     /// Time limit for the Andersen's analyses.
-    static const llvm::cl::opt<unsigned> AnderTimeLimit;
+    static const Option<u32_t> AnderTimeLimit;
 
     /// Number of threads for the versioning phase.
-    static const llvm::cl::opt<unsigned> VersioningThreads;
+    static const Option<u32_t> VersioningThreads;
 
     // ContextDDA.cpp
-    static const llvm::cl::opt<unsigned long long> CxtBudget;
+    static const Option<u32_t> CxtBudget;
 
     // DDAClient.cpp
-    static const llvm::cl::opt<bool> SingleLoad;
-    static const llvm::cl::opt<bool> DumpFree;
-    static const llvm::cl::opt<bool> DumpUninitVar;
-    static const llvm::cl::opt<bool> DumpUninitPtr;
-    static const llvm::cl::opt<bool> DumpSUPts;
-    static const llvm::cl::opt<bool> DumpSUStore;
-    static const llvm::cl::opt<bool> MallocOnly;
-    static const llvm::cl::opt<bool> TaintUninitHeap;
-    static const llvm::cl::opt<bool> TaintUninitStack;
+    static const Option<bool> SingleLoad;
+    static const Option<bool> DumpFree;
+    static const Option<bool> DumpUninitVar;
+    static const Option<bool> DumpUninitPtr;
+    static const Option<bool> DumpSUPts;
+    static const Option<bool> DumpSUStore;
+    static const Option<bool> MallocOnly;
+    static const Option<bool> TaintUninitHeap;
+    static const Option<bool> TaintUninitStack;
 
     // DDAPass.cpp
-    static const llvm::cl::opt<unsigned> MaxPathLen;
-    static const llvm::cl::opt<unsigned> MaxContextLen;
-    static const llvm::cl::opt<unsigned> MaxStepInWrapper;
-    static const llvm::cl::opt<std :: string> UserInputQuery;
-    static const llvm::cl::opt<bool> InsenRecur;
-    static const llvm::cl::opt<bool> InsenCycle;
-    static const llvm::cl::opt<bool> PrintCPts;
-    static const llvm::cl::opt<bool> PrintQueryPts;
-    static const llvm::cl::opt<bool> WPANum;
-    static llvm::cl::bits<PointerAnalysis::PTATY> DDASelected;
+    static const Option<u32_t> MaxPathLen;
+    static const Option<u32_t> MaxContextLen;
+    static const Option<u32_t> MaxStepInWrapper;
+    static const Option<std::string> UserInputQuery;
+    static const Option<bool> InsenRecur;
+    static const Option<bool> InsenCycle;
+    static const Option<bool> PrintCPts;
+    static const Option<bool> PrintQueryPts;
+    static const Option<bool> WPANum;
+    static OptionMultiple<PointerAnalysis::PTATY> DDASelected;
 
     // FlowDDA.cpp
-    static const llvm::cl::opt<unsigned long long> FlowBudget;
+    static const Option<u32_t> FlowBudget;
 
     // Offline constraint graph (OfflineConsG.cpp)
-    static const llvm::cl::opt<bool> OCGDotGraph;
+    static const Option<bool> OCGDotGraph;
 
     // Program Assignment Graph for pointer analysis (SVFIR.cpp)
-    static llvm::cl::opt<bool> HandBlackHole;
-    static const llvm::cl::opt<bool> FirstFieldEqBase;
+    static Option<bool> HandBlackHole;
+    static const Option<bool> FirstFieldEqBase;
 
     // SVFG optimizer (SVFGOPT.cpp)
-    static const llvm::cl::opt<bool> ContextInsensitive;
-    static const llvm::cl::opt<bool> KeepAOFI;
-    static const llvm::cl::opt<std::string> SelfCycle;
+    static const Option<bool> ContextInsensitive;
+    static const Option<bool> KeepAOFI;
+    static const Option<std::string> SelfCycle;
 
     // Sparse value-flow graph (VFG.cpp)
-    static const llvm::cl::opt<bool> DumpVFG;
+    static const Option<bool> DumpVFG;
 
     // Location set for modeling abstract memory object (LocationSet.cpp)
-    static const llvm::cl::opt<bool> SingleStride;
+    static const Option<bool> SingleStride;
 
     // Base class of pointer analyses (PointerAnalysis.cpp)
-    static const llvm::cl::opt<bool> TypePrint;
-    static const llvm::cl::opt<bool> FuncPointerPrint;
-    static const llvm::cl::opt<bool> PTSPrint;
-    static const llvm::cl::opt<bool> PTSAllPrint;
-    static const llvm::cl::opt<bool> PStat;
-    static const llvm::cl::opt<unsigned> StatBudget;
-    static const llvm::cl::opt<bool> PAGDotGraph;
-    static const llvm::cl::opt<bool> ShowSVFIRValue;
-    static const llvm::cl::opt<bool> DumpICFG;
-    static const llvm::cl::opt<bool> CallGraphDotGraph;
-    static const llvm::cl::opt<bool> PAGPrint;
-    static const llvm::cl::opt<unsigned> IndirectCallLimit;
-    static const llvm::cl::opt<bool> UsePreCompFieldSensitive;
-    static const llvm::cl::opt<bool> EnableAliasCheck;
-    static const llvm::cl::opt<bool> EnableThreadCallGraph;
-    static const llvm::cl::opt<bool> ConnectVCallOnCHA;
+    static const Option<bool> TypePrint;
+    static const Option<bool> FuncPointerPrint;
+    static const Option<bool> PTSPrint;
+    static const Option<bool> PTSAllPrint;
+    static const Option<bool> PStat;
+    static const Option<u32_t> StatBudget;
+    static const Option<bool> PAGDotGraph;
+    static const Option<bool> ShowSVFIRValue;
+    static const Option<bool> DumpICFG;
+    static const Option<bool> CallGraphDotGraph;
+    static const Option<bool> PAGPrint;
+    static const Option<u32_t> IndirectCallLimit;
+    static const Option<bool> UsePreCompFieldSensitive;
+    static const Option<bool> EnableAliasCheck;
+    static const Option<bool> EnableThreadCallGraph;
+    static const Option<bool> ConnectVCallOnCHA;
 
     // PointerAnalysisImpl.cpp
-    static const llvm::cl::opt<bool> INCDFPTData;
+    static const Option<bool> INCDFPTData;
 
     // Memory region (MemRegion.cpp)
-    static const llvm::cl::opt<bool> IgnoreDeadFun;
+    static const Option<bool> IgnoreDeadFun;
 
     // Base class of pointer analyses (MemSSA.cpp)
-    static const llvm::cl::opt<bool> DumpMSSA;
-    static const llvm::cl::opt<std :: string> MSSAFun;
+    static const Option<bool> DumpMSSA;
+    static const Option<std::string> MSSAFun;
     // static const llvm::cl::opt<string> MSSAFun;
-    static const llvm::cl::opt<MemSSA::MemPartition> MemPar;
+    static const OptionMap<MemSSA::MemPartition> MemPar;
 
     // SVFG builder (SVFGBuilder.cpp)
-    static const llvm::cl::opt<bool> SVFGWithIndirectCall;
-    static llvm::cl::opt<bool> OPTSVFG;
+    static const Option<bool> SVFGWithIndirectCall;
+    static Option<bool> OPTSVFG;
 
-    static const llvm::cl::opt<std :: string> WriteSVFG;
-    static const llvm::cl::opt<std :: string> ReadSVFG;
+    static const Option<std::string> WriteSVFG;
+    static const Option<std::string> ReadSVFG;
 
     // FSMPTA.cpp
-    static const llvm::cl::opt<bool> UsePCG;
-    static const llvm::cl::opt<bool> IntraLock;
-    static const llvm::cl::opt<bool> ReadPrecisionTDEdge;
-    static const llvm::cl::opt<u32_t> AddModelFlag;
+    static const Option<bool> UsePCG;
+    static const Option<bool> IntraLock;
+    static const Option<bool> ReadPrecisionTDEdge;
+    static const Option<u32_t> AddModelFlag;
 
     // LockAnalysis.cpp
-    static const llvm::cl::opt<bool> PrintLockSpan;
+    static const Option<bool> PrintLockSpan;
 
     // MHP.cpp
-    static const llvm::cl::opt<bool> PrintInterLev;
-    static const llvm::cl::opt<bool> DoLockAnalysis;
+    static const Option<bool> PrintInterLev;
+    static const Option<bool> DoLockAnalysis;
 
     // MTA.cpp
-    static const llvm::cl::opt<bool> AndersenAnno;
-    static const llvm::cl::opt<bool> FSAnno;
+    static const Option<bool> AndersenAnno;
+    static const Option<bool> FSAnno;
 
     // MTAAnnotator.cpp
-    static const llvm::cl::opt<u32_t> AnnoFlag;
+    static const Option<u32_t> AnnoFlag;
 
     // MTAResultValidator.cpp
-    static const llvm::cl::opt<bool> PrintValidRes;
+    static const Option<bool> PrintValidRes;
 
-    static const llvm::cl::opt<bool> LockValid;
+    static const Option<bool> LockValid;
     //MTAStat.cpp
-    static const llvm::cl::opt<bool> AllPairMHP;
+    static const Option<bool> AllPairMHP;
 
     // PCG.cpp
-    //const llvm::cl::opt<bool> TDPrint
+    //const Option<bool> TDPrint
 
     // TCT.cpp
-    static const llvm::cl::opt<bool> TCTDotGraph;
+    static const Option<bool> TCTDotGraph;
 
     // LeakChecker.cpp
-    static const llvm::cl::opt<bool> ValidateTests;
+    static const Option<bool> ValidateTests;
 
     // Source-sink analyzer (SrcSnkDDA.cpp)
-    static const llvm::cl::opt<bool> DumpSlice;
-    static const llvm::cl::opt<unsigned> CxtLimit;
+    static const Option<bool> DumpSlice;
+    static const Option<u32_t> CxtLimit;
 
     // CHG.cpp
-    static const llvm::cl::opt<bool> DumpCHA;
+    static const Option<bool> DumpCHA;
 
     // DCHG.cpp
-    static const llvm::cl::opt<bool> PrintDCHG;
+    static const Option<bool> PrintDCHG;
 
     // LLVMModule.cpp
-    static const llvm::cl::opt<std::string> Graphtxt;
-    static const llvm::cl::opt<bool> SVFMain;
+    static const Option<std::string> Graphtxt;
+    static const Option<bool> SVFMain;
 
     // SymbolTableInfo.cpp
-    static const llvm::cl::opt<bool> LocMemModel;
-    static const llvm::cl::opt<bool> ModelConsts;
-    static const llvm::cl::opt<bool> ModelArrays;
-    static const llvm::cl::opt<bool> SymTabPrint;
+    static const Option<bool> LocMemModel;
+    static const Option<bool> ModelConsts;
+    static const Option<bool> ModelArrays;
+    static const Option<bool> SymTabPrint;
 
     // Conditions.cpp
-    static const llvm::cl::opt<unsigned> MaxZ3Size;
+    static const Option<u32_t> MaxZ3Size;
 
     // SaberCondAllocator.cpp
-    static const llvm::cl::opt<bool> PrintPathCond;
+    static const Option<bool> PrintPathCond;
 
     // SVFUtil.cpp
-    static const llvm::cl::opt<bool> DisableWarn;
+    static const Option<bool> DisableWarn;
 
     // Andersen.cpp
-    static const llvm::cl::opt<bool> ConsCGDotGraph;
-    static const llvm::cl::opt<bool> BriefConsCGDotGraph;
-    static const llvm::cl::opt<bool> PrintCGGraph;
-    // static const llvm::cl::opt<string> WriteAnder;
-    static const llvm::cl::opt<std :: string> WriteAnder;
-    // static const llvm::cl::opt<string> ReadAnder;
-    static const llvm::cl::opt<std :: string> ReadAnder;
-    static const llvm::cl::opt<bool> DiffPts;
-    static llvm::cl::opt<bool> DetectPWC;
-    static const llvm::cl::opt<bool> VtableInSVFIR;
+    static const Option<bool> ConsCGDotGraph;
+    static const Option<bool> BriefConsCGDotGraph;
+    static const Option<bool> PrintCGGraph;
+    // static const Option<string> WriteAnder;
+    static const Option<std::string> WriteAnder;
+    // static const Option<string> ReadAnder;
+    static const Option<std::string> ReadAnder;
+    static const Option<bool> DiffPts;
+    static Option<bool> DetectPWC;
+    static const Option<bool> VtableInSVFIR;
 
     // WPAPass.cpp
-    static const llvm::cl::opt<bool> AnderSVFG;
-    static const llvm::cl::opt<bool> SABERFULLSVFG;
-    static const llvm::cl::opt<bool> PrintAliases;
-    static llvm::cl::bits<PointerAnalysis::PTATY> PASelected;
-    static llvm::cl::bits<WPAPass::AliasCheckRule> AliasRule;
+    static const Option<bool> AnderSVFG;
+    static const Option<bool> SABERFULLSVFG;
+    static const Option<bool> PrintAliases;
+    static OptionMultiple<PointerAnalysis::PTATY> PASelected;
+    static OptionMultiple<WPAPass::AliasCheckRule> AliasRule;
 
     // DOTGraphTraits
-    static const llvm::cl::opt<bool> ShowHiddenNode;
+    static const Option<bool> ShowHiddenNode;
 
     // CFL option
-    static const llvm::cl::opt<std::string> GrammarFilename;
-    static const llvm::cl::opt<std::string> CFLGraph;
-    static const llvm::cl::opt<bool> PrintCFL;
-    static const llvm::cl::opt<bool> FlexSymMap;
-    static const llvm::cl::opt<bool>  PEGTransfer;
-    static const llvm::cl::opt<bool>  CFLSVFG;
+    static const Option<std::string> GrammarFilename;
+    static const Option<std::string> CFLGraph;
+    static const Option<bool> PrintCFL;
+    static const Option<bool> FlexSymMap;
+    static const Option<bool>  PEGTransfer;
+    static const Option<bool>  CFLSVFG;
 
     // Loop Analysis
-    static const llvm::cl::opt<bool> LoopAnalysis;
-    static const llvm::cl::opt<unsigned> LoopBound;
+    static const Option<bool> LoopAnalysis;
+    static const Option<u32_t> LoopBound;
 };
 }  // namespace SVF
 

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

@@ -231,7 +231,7 @@ public:
 
     void setDetectPWC(bool flag)
     {
-        Options::DetectPWC = flag;
+        Options::DetectPWC.setValue(flag);
     }
 
 protected:
@@ -242,7 +242,7 @@ protected:
     /// Handle diff points-to set.
     virtual inline void computeDiffPts(NodeID id)
     {
-        if (Options::DiffPts)
+        if (Options::DiffPts())
         {
             NodeID rep = sccRepNode(id);
             getDiffPTDataTy()->computeDiffPts(rep, getDiffPTDataTy()->getPts(rep));
@@ -251,7 +251,7 @@ protected:
     virtual inline const PointsTo& getDiffPts(NodeID id)
     {
         NodeID rep = sccRepNode(id);
-        if (Options::DiffPts)
+        if (Options::DiffPts())
             return getDiffPTDataTy()->getDiffPts(rep);
         else
             return getPTDataTy()->getPts(rep);
@@ -260,7 +260,7 @@ protected:
     /// Handle propagated points-to set.
     inline void updatePropaPts(NodeID dstId, NodeID srcId)
     {
-        if (!Options::DiffPts)
+        if (!Options::DiffPts())
             return;
         NodeID srcRep = sccRepNode(srcId);
         NodeID dstRep = sccRepNode(dstId);
@@ -268,7 +268,7 @@ protected:
     }
     inline void clearPropaPts(NodeID src)
     {
-        if (Options::DiffPts)
+        if (Options::DiffPts())
         {
             NodeID rep = sccRepNode(src);
             getDiffPTDataTy()->clearPropaPts(rep);

package/package.json

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