svf-lib 1.0.993 → 1.0.994

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
     }

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

@@ -27,12 +27,14 @@
  *      Author: Yulei Sui
  */
 #ifndef CFLGrammar_H_
-#define CFLGrammar_H_  
+#define CFLGrammar_H_
 #include "Util/BasicTypes.h"
 
-namespace SVF{
+namespace SVF
+{
 
-class GrammarBase{
+class GrammarBase
+{
 public:
     typedef u32_t Symbol;
     typedef std::vector<Symbol> Production;
@@ -41,10 +43,11 @@ public:
     Map<std::string, Symbol> nonterminals;
 
     Symbol str2Sym(std::string str) const;
-    
+
     std::string sym2Str(Symbol sym) const;
 
-    Symbol getSymbol(const Production& prod, u32_t pos){
+    Symbol getSymbol(const Production& prod, u32_t pos)
+    {
         return prod.at(pos);
     }
 
@@ -56,7 +59,8 @@ public:
     Map<Symbol, Productions> rawProductions;
 };
 
-class CFLGrammar : public GrammarBase{
+class CFLGrammar : public GrammarBase
+{
 
 public:
     Set<Production > epsilonProds;
@@ -66,52 +70,62 @@ public:
     Symbol newTerminalSubscript;
     CFLGrammar();
 
-    const Productions& getEpsilonProds() const{
+    const Productions& getEpsilonProds() const
+    {
         return epsilonProds;
     }
 
-    const bool hasProdsFromFirstRHS(Symbol sym) const{
+    const bool hasProdsFromFirstRHS(Symbol sym) const
+    {
         auto it = firstRHS2Prods.find(sym);
         return it!=firstRHS2Prods.end();
     }
 
-    const bool hasProdsFromSingleRHS(Symbol sym) const{
+    const bool hasProdsFromSingleRHS(Symbol sym) const
+    {
         auto it = singleRHS2Prods.find(sym);
         return it!=singleRHS2Prods.end();
     }
 
-    const bool hasProdsFromSecondRHS(Symbol sym) const{
+    const bool hasProdsFromSecondRHS(Symbol sym) const
+    {
         auto it = secondRHS2Prods.find(sym);
         return it!=secondRHS2Prods.end();
     }
 
-    const Productions& getProdsFromSingleRHS(Symbol sym) const{
+    const Productions& getProdsFromSingleRHS(Symbol sym) const
+    {
         auto it = singleRHS2Prods.find(sym);
         assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
         return it->second;
     }
 
-    const Productions& getProdsFromFirstRHS(Symbol sym) const{
+    const Productions& getProdsFromFirstRHS(Symbol sym) const
+    {
         auto it = firstRHS2Prods.find(sym);
         assert(it!=firstRHS2Prods.end() && "production (X -> sym Y) not found for sym!!");
         return it->second;
     }
 
-    const Productions& getProdsFromSecondRHS(Symbol sym) const{
+    const Productions& getProdsFromSecondRHS(Symbol sym) const
+    {
         auto it = secondRHS2Prods.find(sym);
         assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
         return it->second;
     }
 
-    Symbol getLHSSymbol(const Production& prod){
+    Symbol getLHSSymbol(const Production& prod)
+    {
         return prod.at(0);
     }
 
-    Symbol getFirstRHSSymbol(const Production& prod){
+    Symbol getFirstRHSSymbol(const Production& prod)
+    {
         return prod.at(1);
     }
 
-    Symbol getSecondRHSSymbol(const Production& prod){
+    Symbol getSecondRHSSymbol(const Production& prod)
+    {
         return prod.at(2);
     }
 

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

@@ -32,9 +32,11 @@
 #include "Util/WorkList.h"
 
 
-namespace SVF{
+namespace SVF
+{
 
-class CFLSolver{
+class CFLSolver
+{
 
 public:
     /// Define worklist
@@ -54,12 +56,14 @@ public:
     void solve();
 
     /// Return CFL Graph
-    inline const CFLGraph* getGraph() const {
+    inline const CFLGraph* getGraph() const
+    {
         return graph;
     }
 
     /// Return CFL Grammar
-    inline const CFLGrammar* getGrammar() const {
+    inline const CFLGrammar* getGrammar() const
+    {
         return grammar;
     }
 
@@ -84,7 +88,7 @@ protected:
     }
     //@}
 
-private: 
+private:
     CFLGraph* graph;
     CFLGrammar* grammar;
     /// Worklist for resolution

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

@@ -31,13 +31,14 @@
 #include "CFL/CFLGrammar.h"
 #include "Graphs/CFLGraph.h"
 
-namespace SVF{
+namespace SVF
+{
 
 /*!
  * Build Grammar from a user specified grammar text
  * Input Format:
  *      Start:              // Special string 'epsilon' for empty RHS
- *      M                   // Specify Start Symbol in Second Line 
+ *      M                   // Specify Start Symbol in Second Line
  *      Productions:        // Each Symbol seperate by 'Space', production end with ';'
  *      M -> V d;           // Terminal in NonCapital
  *      M -> dbar V d;      // NonTerminal in Capital
@@ -45,21 +46,23 @@ namespace SVF{
  *      V -> ( M ? abar ) * M ? ( a M ? ) *;    // Support '(' ')' '?' '*' four regular expression sign
  * Note:
  *      When provide EBNF form text (i.e Last production above),
- *      Please specify -ebnf flag, otherwise regular experssion sign will treat as NonTerminal. 
+ *      Please specify -ebnf flag, otherwise regular experssion sign will treat as NonTerminal.
  */
 
-class GrammarBuilder{
+class GrammarBuilder
+{
 public:
     std::string fileName;
     GrammarBase *grammar;
 
-    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr){
+    GrammarBuilder(std::string fileName): fileName(fileName), grammar(nullptr)
+    {
         grammar = new GrammarBase();
     };
 
-    GrammarBase* build(); 
+    GrammarBase* build();
 
     GrammarBase* build(Map<std::string, SVF::CFLGraph::Symbol> *preMap);
 };
 
-} // SVF 
+} // SVF

package/SVF-osx/include/CUDD/cudd.h

@@ -138,7 +138,8 @@ extern "C" {
   Description [Type of reordering algorithm.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_REORDER_SAME,
     CUDD_REORDER_NONE,
     CUDD_REORDER_RANDOM,
@@ -171,7 +172,8 @@ typedef enum {
   Description [Type of aggregation methods.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_NO_CHECK,
     CUDD_GROUP_CHECK,
     CUDD_GROUP_CHECK2,
@@ -192,7 +194,8 @@ typedef enum {
   Description [Type of hooks.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_PRE_GC_HOOK,
     CUDD_POST_GC_HOOK,
     CUDD_PRE_REORDERING_HOOK,
@@ -207,7 +210,8 @@ typedef enum {
   Description [Type of  error codes.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_NO_ERROR,
     CUDD_MEMORY_OUT,
     CUDD_TOO_MANY_NODES,
@@ -225,7 +229,8 @@ typedef enum {
   Description [Group type for lazy sifting.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_LAZY_NONE,
     CUDD_LAZY_SOFT_GROUP,
     CUDD_LAZY_HARD_GROUP,
@@ -240,7 +245,8 @@ typedef enum {
   Description [Variable type. Currently used only in lazy sifting.]
 
 ******************************************************************************/
-typedef enum {
+typedef enum
+{
     CUDD_VAR_PRIMARY_INPUT,
     CUDD_VAR_PRESENT_STATE,
     CUDD_VAR_NEXT_STATE
@@ -255,19 +261,22 @@ typedef unsigned short DdHalfWord;
 
 typedef struct DdNode DdNode;
 
-typedef struct DdChildren {
+typedef struct DdChildren
+{
     struct DdNode *T;
     struct DdNode *E;
 } DdChildren;
 
 /* The DdNode structure is the only one exported out of the package */
-struct DdNode {
+struct DdNode
+{
     DdHalfWord index;
     DdHalfWord ref;		/* reference count */
     DdNode *next;		/* next pointer for unique table */
-    union {
-	CUDD_VALUE_TYPE value;	/* for constant nodes */
-	DdChildren kids;	/* for internal nodes */
+    union
+    {
+        CUDD_VALUE_TYPE value;	/* for constant nodes */
+        DdChildren kids;	/* for internal nodes */
     } type;
 };
 

package/SVF-osx/include/CUDD/cuddInt.h

@@ -101,7 +101,7 @@ extern "C" {
 #define DD_MAXREF		((DdHalfWord) ~0)
 
 #define DD_DEFAULT_RESIZE	10	/* how many extra variables */
-					/* should be added when resizing */
+/* should be added when resizing */
 #define DD_MEM_CHUNK		1022
 
 /* These definitions work for CUDD_VALUE_TYPE == double */
@@ -188,7 +188,7 @@ extern "C" {
 #define DD_ADD_OUT_SUM_TAG			0x6e
 #define DD_BDD_LEQ_UNLESS_TAG			0x82
 #define DD_ADD_TRIANGLE_TAG			0x86
-#define DD_BDD_MAX_EXP_TAG			0x8a 
+#define DD_BDD_MAX_EXP_TAG			0x8a
 
 /* Generator constants. */
 #define CUDD_GEN_CUBES 0
@@ -203,26 +203,32 @@ extern "C" {
 /* Stucture declarations                                                     */
 /*---------------------------------------------------------------------------*/
 
-struct DdGen {
+struct DdGen
+{
     DdManager	*manager;
     int		type;
     int		status;
-    union {
-	struct {
-	    int			*cube;
-	    CUDD_VALUE_TYPE	value;
-	} cubes;
-	struct {
-	    int			*cube;
-	    DdNode		*ub;
-	} primes;
-	struct {
-	    int                 size;
-	} nodes;
+    union
+    {
+        struct
+        {
+            int			*cube;
+            CUDD_VALUE_TYPE	value;
+        } cubes;
+        struct
+        {
+            int			*cube;
+            DdNode		*ub;
+        } primes;
+        struct
+        {
+            int                 size;
+        } nodes;
     } gen;
-    struct {
-	int	sp;
-	DdNode	**stack;
+    struct
+    {
+        int	sp;
+        DdNode	**stack;
     } stack;
     DdNode	*node;
 };
@@ -237,7 +243,8 @@ struct DdGen {
 ** are passed the manager as argument; they should return 1 if
 ** successful and 0 otherwise.
 */
-typedef struct DdHook {		/* hook list element */
+typedef struct DdHook  		/* hook list element */
+{
     DD_HFP f; /* function to be called */
     struct DdHook *next;	/* next element in the list */
 } DdHook;
@@ -253,7 +260,8 @@ typedef unsigned int ptruint;
 typedef DdNode *DdNodePtr;
 
 /* Generic local cache item. */
-typedef struct DdLocalCacheItem {
+typedef struct DdLocalCacheItem
+{
     DdNode *value;
 #ifdef DD_CACHE_PROFILE
     ptrint count;
@@ -262,7 +270,8 @@ typedef struct DdLocalCacheItem {
 } DdLocalCacheItem;
 
 /* Local cache. */
-typedef struct DdLocalCache {
+typedef struct DdLocalCache
+{
     DdLocalCacheItem *item;
     unsigned int itemsize;
     unsigned int keysize;
@@ -277,7 +286,8 @@ typedef struct DdLocalCache {
 } DdLocalCache;
 
 /* Generic hash item. */
-typedef struct DdHashItem {
+typedef struct DdHashItem
+{
     struct DdHashItem *next;
     ptrint count;
     DdNode *value;
@@ -285,7 +295,8 @@ typedef struct DdHashItem {
 } DdHashItem;
 
 /* Local hash table */
-typedef struct DdHashTable {
+typedef struct DdHashTable
+{
     unsigned int keysize;
     unsigned int itemsize;
     DdHashItem **bucket;
@@ -298,7 +309,8 @@ typedef struct DdHashTable {
     DdManager *manager;
 } DdHashTable;
 
-typedef struct DdCache {
+typedef struct DdCache
+{
     DdNode *f,*g;		/* DDs */
     ptruint h;			/* either operator or DD */
     DdNode *data;		/* already constructed DD */
@@ -307,7 +319,8 @@ typedef struct DdCache {
 #endif
 } DdCache;
 
-typedef struct DdSubtable {	/* subtable for one index */
+typedef struct DdSubtable  	/* subtable for one index */
+{
     DdNode **nodelist;		/* hash table */
     int shift;			/* shift for hash function */
     unsigned int slots;		/* size of the hash table */
@@ -323,7 +336,8 @@ typedef struct DdSubtable {	/* subtable for one index */
     Cudd_LazyGroupType varToBeGrouped; /* tells what grouping to apply */
 } DdSubtable;
 
-struct DdManager {	/* specialized DD symbol table */
+struct DdManager  	/* specialized DD symbol table */
+{
     /* Constants */
     DdNode sentinel;		/* for collision lists */
     DdNode *one;		/* constant 1 */
@@ -359,11 +373,11 @@ struct DdManager {	/* specialized DD symbol table */
     double gcFrac;		/* gc when this fraction is dead */
     int gcEnabled;		/* gc is enabled */
     unsigned int looseUpTo;	/* slow growth beyond this limit */
-				/* (measured w.r.t. slots, not keys) */
+    /* (measured w.r.t. slots, not keys) */
     unsigned int initSlots;	/* initial size of a subtable */
     DdNode **stack;		/* stack for iterative procedures */
     double allocated;		/* number of nodes allocated */
-				/* (not during reordering) */
+    /* (not during reordering) */
     double reclaimed;		/* number of nodes brought back from the dead */
     int isolated;		/* isolated projection functions */
     int *perm;			/* current variable perm. (index to level) */
@@ -466,7 +480,8 @@ struct DdManager {	/* specialized DD symbol table */
 #endif
 };
 
-typedef struct Move {
+typedef struct Move
+{
     DdHalfWord x;
     DdHalfWord y;
     unsigned int flags;
@@ -475,14 +490,16 @@ typedef struct Move {
 } Move;
 
 /* Generic level queue item. */
-typedef struct DdQueueItem {
+typedef struct DdQueueItem
+{
     struct DdQueueItem *next;
     struct DdQueueItem *cnext;
     void *key;
 } DdQueueItem;
 
 /* Level queue. */
-typedef struct DdLevelQueue {
+typedef struct DdLevelQueue
+{
     void *first;
     DdQueueItem **last;
     DdQueueItem *freelist;