svf-lib 1.0.992 → 1.0.995

package/SVF-linux/include/Util/Z3Expr.h

@@ -32,202 +32,249 @@
 #include "z3++.h"
 #include "Util/SVFBasicTypes.h"
 
-namespace SVF {
+namespace SVF
+{
 
-    class Z3Expr {
-    public:
-        static z3::context *ctx;
+class Z3Expr
+{
+public:
+    static z3::context *ctx;
 
-    private:
-        z3::expr e;
+private:
+    z3::expr e;
 
-        Z3Expr(float f); // placeholder don't support floating point expression
-        Z3Expr(double f); // placeholder don't support floating point expression
+    Z3Expr(float f); // placeholder don't support floating point expression
+    Z3Expr(double f); // placeholder don't support floating point expression
 
-    public:
+public:
 
-        Z3Expr() : e(nullExpr()) {
-        }
+    Z3Expr() : e(nullExpr())
+    {
+    }
 
-        Z3Expr(const z3::expr &_e) : e(_e) {
-        }
+    Z3Expr(const z3::expr &_e) : e(_e)
+    {
+    }
 
-        Z3Expr(int i) : e(getContext().int_val(i)) {
-        }
+    Z3Expr(int i) : e(getContext().int_val(i))
+    {
+    }
 
-        Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr()) {
-        }
+    Z3Expr(const Z3Expr &z3Expr) : e(z3Expr.getExpr())
+    {
+    }
 
-        virtual ~Z3Expr() = default;
+    virtual ~Z3Expr() = default;
 
-        inline Z3Expr &operator=(const Z3Expr &rhs) {
-            if (this->id() != rhs.id()) {
-                e = rhs.getExpr();
-            }
-            return *this;
+    inline Z3Expr &operator=(const Z3Expr &rhs)
+    {
+        if (this->id() != rhs.id())
+        {
+            e = rhs.getExpr();
         }
+        return *this;
+    }
 
-        const z3::expr &getExpr() const {
-            return e;
-        }
+    const z3::expr &getExpr() const
+    {
+        return e;
+    }
 
-        /// Get z3 context, singleton design here to make sure we only have one context
-        static z3::context &getContext() {
-            if (ctx == nullptr) {
-                ctx = new z3::context();
-            }
-            return *ctx;
+    /// Get z3 context, singleton design here to make sure we only have one context
+    static z3::context &getContext()
+    {
+        if (ctx == nullptr)
+        {
+            ctx = new z3::context();
         }
+        return *ctx;
+    }
 
-        /// release z3 context
-        static void releaseContext() {
-            delete ctx;
-            ctx = nullptr;
-        }
+    /// release z3 context
+    static void releaseContext()
+    {
+        delete ctx;
+        ctx = nullptr;
+    }
 
-        /// null expression
-        static z3::expr nullExpr() {
-            return getContext().int_const("null");
-        }
+    /// null expression
+    static z3::expr nullExpr()
+    {
+        return getContext().int_const("null");
+    }
 
-        /// get id
-        inline u32_t id() const {
-            return e.id();
-        }
+    /// get id
+    inline u32_t id() const
+    {
+        return e.id();
+    }
 
-        inline const std::string to_string() const {
-            return e.to_string();
-        }
+    inline const std::string to_string() const
+    {
+        return e.to_string();
+    }
 
-        inline bool is_numeral() const {
-            return e.is_numeral();
-        }
+    inline bool is_numeral() const
+    {
+        return e.is_numeral();
+    }
 
-        inline bool is_bool() const {
-            return e.is_bool();
-        }
+    inline bool is_bool() const
+    {
+        return e.is_bool();
+    }
 
-        inline Z3Expr simplify() const {
-            return e.simplify();
-        }
+    inline Z3Expr simplify() const
+    {
+        return e.simplify();
+    }
 
-        inline int64_t get_numeral_int64() const {
-            return e.get_numeral_int64();
-        }
+    inline int64_t get_numeral_int64() const
+    {
+        return e.get_numeral_int64();
+    }
 
-        inline int get_numeral_int() const {
-            return e.get_numeral_int();
-        }
+    inline int get_numeral_int() const
+    {
+        return e.get_numeral_int();
+    }
 
-        //{% reload operator
-        friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() == rhs.getExpr();
-        }
+    //{% reload operator
+    friend Z3Expr operator==(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() == rhs.getExpr();
+    }
 
-        friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() != rhs.getExpr();
-        }
+    friend Z3Expr operator!=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() != rhs.getExpr();
+    }
 
-        friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() > rhs.getExpr();
-        }
+    friend Z3Expr operator>(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() > rhs.getExpr();
+    }
 
-        friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() < rhs.getExpr();
-        }
+    friend Z3Expr operator<(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() < rhs.getExpr();
+    }
 
-        friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() <= rhs.getExpr();
-        }
+    friend Z3Expr operator<=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() <= rhs.getExpr();
+    }
 
-        friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() >= rhs.getExpr();
-        }
+    friend Z3Expr operator>=(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() >= rhs.getExpr();
+    }
 
-        friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() + rhs.getExpr();
-        }
+    friend Z3Expr operator+(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() + rhs.getExpr();
+    }
 
-        friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() - rhs.getExpr();
-        }
+    friend Z3Expr operator-(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() - rhs.getExpr();
+    }
 
-        friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() * rhs.getExpr();
-        }
+    friend Z3Expr operator*(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() * rhs.getExpr();
+    }
 
-        friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() / rhs.getExpr();
-        }
+    friend Z3Expr operator/(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() / rhs.getExpr();
+    }
 
-        friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() % rhs.getExpr();
-        }
+    friend Z3Expr operator%(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() % rhs.getExpr();
+    }
 
-        friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() ^ rhs.getExpr();
-        }
+    friend Z3Expr operator^(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() ^ rhs.getExpr();
+    }
 
-        friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() & rhs.getExpr();
-        }
+    friend Z3Expr operator&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() & rhs.getExpr();
+    }
 
-        friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() | rhs.getExpr();
-        }
+    friend Z3Expr operator|(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() | rhs.getExpr();
+    }
 
-        friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return ashr(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ashr(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return ashr(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return shl(lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr shl(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return shl(lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend Z3Expr int2bv(u32_t n, const Z3Expr &e) {
-            return int2bv(n, e.getExpr());
-        }
+    friend Z3Expr int2bv(u32_t n, const Z3Expr &e)
+    {
+        return int2bv(n, e.getExpr());
+    }
 
-        friend Z3Expr bv2int(const Z3Expr &e, bool isSigned) {
-            return z3::bv2int(e.getExpr(), isSigned);
-        }
+    friend Z3Expr bv2int(const Z3Expr &e, bool isSigned)
+    {
+        return z3::bv2int(e.getExpr(), isSigned);
+    }
 
-        friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() && rhs.getExpr();
-        }
+    friend Z3Expr operator&&(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() && rhs.getExpr();
+    }
 
-        friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return lhs.getExpr() || rhs.getExpr();
-        }
+    friend Z3Expr operator||(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return lhs.getExpr() || rhs.getExpr();
+    }
 
-        friend Z3Expr operator!(const Z3Expr &lhs) {
-            return !lhs.getExpr();
-        }
+    friend Z3Expr operator!(const Z3Expr &lhs)
+    {
+        return !lhs.getExpr();
+    }
 
-        friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs) {
-            return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
-        }
+    friend Z3Expr ite(const Z3Expr& cond, const Z3Expr& lhs, const Z3Expr& rhs)
+    {
+        return ite(cond.getExpr(), lhs.getExpr(), rhs.getExpr());
+    }
 
-        friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr) {
-            out << expr.getExpr();
-            return out;
-        }
+    friend std::ostream &operator<<(std::ostream &out, const Z3Expr &expr)
+    {
+        out << expr.getExpr();
+        return out;
+    }
 
-        friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs) {
-            return eq(lhs.getExpr(), rhs.getExpr());
-        }
+    friend bool eq(const Z3Expr &lhs, const Z3Expr &rhs)
+    {
+        return eq(lhs.getExpr(), rhs.getExpr());
+    }
 
-        z3::sort get_sort() const {
-            return getExpr().get_sort();
-        }
-        //%}
-    };
+    z3::sort get_sort() const
+    {
+        return getExpr().get_sort();
+    }
+    //%}
+};
 }
 
 /// Specialise hash for AbsCxtDPItem.
 template<>
-struct std::hash<SVF::Z3Expr> {
-    size_t operator()(const SVF::Z3Expr &z3Expr) const {
+struct std::hash<SVF::Z3Expr>
+{
+    size_t operator()(const SVF::Z3Expr &z3Expr) const
+    {
         return z3Expr.id();
     }
 };

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

@@ -85,16 +85,16 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return ( pta->getAnalysisTy() == Andersen_BASE
-				|| pta->getAnalysisTy() == Andersen_WPA
-                || pta->getAnalysisTy() == AndersenLCD_WPA
-                || pta->getAnalysisTy() == AndersenHCD_WPA
-                || pta->getAnalysisTy() == AndersenHLCD_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiff_WPA
-                || pta->getAnalysisTy() == AndersenWaveDiffWithType_WPA
-                || pta->getAnalysisTy() == AndersenSCD_WPA
-                || pta->getAnalysisTy() == AndersenSFR_WPA
-				|| pta->getAnalysisTy() == TypeCPP_WPA
-				|| pta->getAnalysisTy() == Steensgaard_WPA);
+                 || pta->getAnalysisTy() == Andersen_WPA
+                 || pta->getAnalysisTy() == AndersenLCD_WPA
+                 || pta->getAnalysisTy() == AndersenHCD_WPA
+                 || pta->getAnalysisTy() == AndersenHLCD_WPA
+                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA
+                 || pta->getAnalysisTy() == AndersenWaveDiffWithType_WPA
+                 || pta->getAnalysisTy() == AndersenSCD_WPA
+                 || pta->getAnalysisTy() == AndersenSFR_WPA
+                 || pta->getAnalysisTy() == TypeCPP_WPA
+                 || pta->getAnalysisTy() == Steensgaard_WPA);
     }
     //@}
 
@@ -190,7 +190,7 @@ public:
     static inline bool classof(const PointerAnalysis *pta)
     {
         return (pta->getAnalysisTy() == Andersen_WPA
-				|| pta->getAnalysisTy() == AndersenLCD_WPA
+                || pta->getAnalysisTy() == AndersenLCD_WPA
                 || pta->getAnalysisTy() == AndersenHCD_WPA
                 || pta->getAnalysisTy() == AndersenHLCD_WPA
                 || pta->getAnalysisTy() == AndersenWaveDiff_WPA

package/SVF-linux/include/WPA/VersionedFlowSensitive.h

@@ -99,7 +99,10 @@ protected:
     virtual void updateConnectedNodes(const SVFGEdgeSetTy& newEdges) override;
 
     /// Override to do nothing. Instead, we will use propagateVersion when necessary.
-    virtual bool propAlongIndirectEdge(const IndirectSVFGEdge*) override { return false; }
+    virtual bool propAlongIndirectEdge(const IndirectSVFGEdge*) override
+    {
+        return false;
+    }
 
     /// Override since we want to assign different weights based on versioning.
     virtual void cluster(void) override;

package/SVF-osx/include/CFL/CFGNormalizer.h

@@ -32,20 +32,23 @@
 
 #include "CFLGrammar.h"
 
-namespace SVF{
+namespace SVF
+{
 
 /*!
  *  Normalize Grammar from a grammarbase
  */
 
-class CFGNormalizer {
+class CFGNormalizer
+{
 
 public:
     typedef u32_t Symbol;
     typedef std::vector<Symbol> Production;
     typedef Set<Production> Productions;
 
-    CFGNormalizer(){
+    CFGNormalizer()
+    {
     }
 
     /// Start Normalize (BIN Only)

package/SVF-osx/include/CFL/CFLAlias.h

@@ -35,30 +35,36 @@
 #include "Graphs/ConsG.h"
 #include "Util/Options.h"
 
-namespace SVF{
+namespace SVF
+{
 
-class CFLAlias : public PointerAnalysis{
+class CFLAlias : public PointerAnalysis
+{
 
 public:
-    CFLAlias(SVFIR* ir) : PointerAnalysis(ir, PointerAnalysis::CFLFICI_WPA), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr){
+    CFLAlias(SVFIR* ir) : PointerAnalysis(ir, PointerAnalysis::CFLFICI_WPA), svfir(ir), graph(nullptr), grammar(nullptr), solver(nullptr)
+    {
     }
 
     /// Destructor
-    virtual ~CFLAlias(){
+    virtual ~CFLAlias()
+    {
         delete graph;
         delete grammar;
         delete solver;
     }
 
-    /// Start Analysis here (main part of pointer analysis). 
-    virtual void analyze(){
+    /// Start Analysis here (main part of pointer analysis).
+    virtual void analyze()
+    {
         PointerAnalysis::initialize();
         GrammarBuilder * gReader = new GrammarBuilder(Options::GrammarFilename);
         CFGNormalizer *normalizer = new CFGNormalizer();
-        
+
         graph = new CFLGraph();
-        if (Options::GraphIsFromDot == false){
-            // Maybe could put in SVFIR Class 
+        if (Options::GraphIsFromDot == false)
+        {
+            // Maybe could put in SVFIR Class
             // In memory Graph does not have string type label
             Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar", 10},{"Vgepbar", 11}};
             ConstraintGraph *consCG = new ConstraintGraph(svfir);
@@ -72,11 +78,12 @@ public:
             grammar = normalizer->normalize(generalGrammar);
             graph->setMap(&grammar->terminals, &grammar->nonterminals);
         }
-        else {
+        else
+        {
             GrammarBase *generalGrammar = gReader->build();
             grammar = normalizer->normalize(generalGrammar);
             graph->setMap(&grammar->terminals, &grammar->nonterminals);
-            graph->buildFromDot(Options::InputFilename);     
+            graph->buildFromDot(Options::InputFilename);
         }
         graph->startSymbol = grammar->startSymbol;
         solver = new CFLSolver(graph, grammar);
@@ -86,14 +93,16 @@ public:
     }
 
     /// Interface exposed to users of our pointer analysis, given Value infos
-    virtual AliasResult alias(const Value* v1, const Value* v2) {
+    virtual AliasResult alias(const Value* v1, const Value* v2)
+    {
         NodeID n1 = svfir->getValueNode(v1);
         NodeID n2 = svfir->getValueNode(v2);
         return alias(n1,n2);
     }
 
     /// Interface exposed to users of our pointer analysis, given PAGNodeID
-    virtual AliasResult alias(NodeID node1, NodeID node2) {
+    virtual AliasResult alias(NodeID node1, NodeID node2)
+    {
         /// TODO:: Fix the edge label for a reachable alias relation if it is not 1;
         if(graph->hasEdge(graph->getGNode(node1), graph->getGNode(node2), graph->startSymbol))
             return AliasResult::MayAlias;
@@ -102,14 +111,16 @@ public:
     }
 
     /// Get points-to targets of a pointer.
-    virtual const PointsTo& getPts(NodeID ptr) {
+    virtual const PointsTo& getPts(NodeID ptr)
+    {
         /// Check Outgoing edge Dst of ptr
         //PointsTo * ps;
         abort(); // to be implemented
     }
 
     /// Given an object, get all the nodes having whose pointsto contains the object
-    virtual const NodeSet& getRevPts(NodeID nodeId) {
+    virtual const NodeSet& getRevPts(NodeID nodeId)
+    {
         /// Check Outgoing flowtobar edge dst of ptr
         abort(); // to be implemented
     }