svf-lib 1.0.1035 → 1.0.1038

package/SVF-linux/include/SVF-FE/BasicTypes.h

@@ -57,6 +57,7 @@ typedef llvm::ConstantDataSequential ConstantDataSequential;
 typedef llvm::ConstantExpr ConstantExpr;
 typedef llvm::ConstantDataArray ConstantDataArray;
 typedef llvm::ConstantData ConstantData;
+typedef llvm::ConstantArray ConstantArray;
 
 // LLVM Instructions
 typedef llvm::AllocaInst AllocaInst;

package/SVF-linux/include/SVF-FE/Graph2Json.h

@@ -5,7 +5,7 @@
 #include "Graphs/ICFG.h"
 #include "Graphs/ICFGNode.h"
 #include "Graphs/ICFGEdge.h"
-#include "SVF-FE/LLVMUtil.h"
+#include "Util/SVFUtil.h"
 
 namespace SVF
 {

package/SVF-linux/include/SVF-FE/LLVMUtil.h

@@ -66,14 +66,6 @@ inline bool isBlackholeSym(const Value *val)
 }
 
 
-/// Return true if the call is an external call (external library in function summary table)
-/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
-//@{
-inline bool isExtCall(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_ext(fun);
-}
-
 inline bool isExtCall(const CallSite cs)
 {
     return isExtCall(getCallee(cs));
@@ -91,19 +83,6 @@ inline bool isReturn(const Instruction* inst)
     return SVFUtil::isa<ReturnInst>(inst);
 }
 
-/// Return true if the call is a heap allocator/reallocator
-//@{
-/// note that these two functions are not suppose to be used externally
-inline bool isHeapAllocExtFunViaRet(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_alloc(fun)
-                   || ExtAPI::getExtAPI()->is_realloc(fun));
-}
-inline bool isHeapAllocExtFunViaArg(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_arg_alloc(fun);
-}
-
 static inline Type *getPtrElementType(const PointerType* pty)
 {
 #if (LLVM_VERSION_MAJOR < 14)
@@ -148,13 +127,6 @@ inline bool isHeapAllocExtCall(const Instruction *inst)
 }
 //@}
 
-/// Get the position of argument that holds an allocated heap object.
-//@{
-inline int getHeapAllocHoldingArgPosition(const SVFFunction* fun)
-{
-    return ExtAPI::getExtAPI()->get_alloc_arg_pos(fun);
-}
-
 inline int getHeapAllocHoldingArgPosition(const CallSite cs)
 {
     return getHeapAllocHoldingArgPosition(getCallee(cs));
@@ -166,14 +138,6 @@ inline int getHeapAllocHoldingArgPosition(const Instruction *inst)
 }
 //@}
 
-/// Return true if the call is a heap reallocator
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isReallocExtFun(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
-}
-
 inline bool isReallocExtCall(const CallSite cs)
 {
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
@@ -187,14 +151,6 @@ inline bool isReallocExtCall(const Instruction *inst)
 }
 //@}
 
-/// Return true if the call is a heap dealloc or not
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isDeallocExtFun(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_dealloc(fun));
-}
-
 inline bool isDeallocExtCall(const CallSite cs)
 {
     return isDeallocExtFun(getCallee(cs));
@@ -206,15 +162,6 @@ inline bool isDeallocExtCall(const Instruction *inst)
 }
 //@}
 
-
-/// Return true if the call is a static global call
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isStaticExtFun(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->has_static(fun);
-}
-
 inline bool isStaticExtCall(const CallSite cs)
 {
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
@@ -241,12 +188,6 @@ inline bool isHeapAllocOrStaticExtCall(const Instruction *inst)
 }
 //@}
 
-/// Return external call type
-inline ExtAPI::extf_t extCallTy(const SVFFunction* fun)
-{
-    return ExtAPI::getExtAPI()->get_type(fun);
-}
-
 /// Get the reference type of heap/static object from an allocation site.
 //@{
 inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
@@ -362,18 +303,6 @@ inline bool isBarrierWaitCall(const Instruction *inst)
 }
 //@}
 
-/// Return thread fork function
-//@{
-inline const Value* getForkedFun(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->getForkedFun(cs);
-}
-inline const Value* getForkedFun(const Instruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->getForkedFun(inst);
-}
-//@}
-
 /// Return sole argument of the thread routine
 //@{
 inline const Value* getActualParmAtForkSite(const CallSite cs)
@@ -413,15 +342,6 @@ inline const Value* getTaskDataAtHareParForSite(const Instruction *inst)
 /// Return true if this value refers to a object
 bool isObject (const Value * ref);
 
-/// Return true if the value refers to constant data, e.g., i32 0
-inline bool isConstantData(const Value* val)
-{
-    return SVFUtil::isa<ConstantData>(val)
-           || SVFUtil::isa<ConstantAggregate>(val)
-           || SVFUtil::isa<MetadataAsValue>(val)
-           || SVFUtil::isa<BlockAddress>(val);
-}
-
 /// Method for dead function, which does not have any possible caller
 /// function address is not taken and never be used in call or invoke instruction
 //@{
@@ -436,43 +356,11 @@ inline bool ArgInDeadFunction (const Value * val)
 }
 //@}
 
-/// Program entry function e.g. main
-//@{
-/// Return true if this is a program entry function (e.g. main)
-inline bool isProgEntryFunction (const SVFFunction * fun)
-{
-    return fun && fun->getName() == "main";
-}
-
 inline bool isProgEntryFunction (const Function * fun)
 {
     return fun && fun->getName() == "main";
 }
 
-/// Get program entry function from module.
-inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (fun->getName()==funName)
-            return fun;
-    }
-    return nullptr;
-}
-
-/// Get program entry function from module.
-inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (isProgEntryFunction(fun))
-            return (fun);
-    }
-    return nullptr;
-}
-
 /// Return true if this is an argument of a program entry function (e.g. main)
 inline bool ArgInProgEntryFunction (const Value * val)
 {
@@ -483,15 +371,6 @@ inline bool ArgInProgEntryFunction (const Value * val)
 bool isPtrInDeadFunction (const Value * value);
 //@}
 
-/// Return true if this is a program exit function call
-//@{
-inline bool isProgExitFunction (const SVFFunction * fun)
-{
-    return fun && (fun->getName() == "exit" ||
-                   fun->getName() == "__assert_rtn" ||
-                   fun->getName() == "__assert_fail" );
-}
-
 inline bool isProgExitCall(const CallSite cs)
 {
     return isProgExitFunction(getCallee(cs));
@@ -677,7 +556,6 @@ u32_t getTypeSizeInBytes(const Type* type);
 u32_t getTypeSizeInBytes(const StructType *sty, u32_t field_index);
 //@}
 
-const std::string type2String(const Type* type);
 
 } // End namespace SVFUtil
 

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

@@ -94,7 +94,6 @@ typedef llvm::Argument Argument;
 typedef llvm::Constant Constant;
 typedef llvm::ConstantInt ConstantInt;
 typedef llvm::ConstantPointerNull ConstantPointerNull;
-typedef llvm::ConstantArray ConstantArray;
 typedef llvm::GlobalAlias GlobalAlias;
 
 /// LLVM metadata

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

@@ -352,6 +352,130 @@ bool startAnalysisLimitTimer(unsigned timeLimit);
 /// timer or not (return value of startLimitTimer).
 void stopAnalysisLimitTimer(bool limitTimerSet);
 
+/// Return true if the call is an external call (external library in function summary table)
+/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
+//@{
+inline bool isExtCall(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->is_ext(fun);
+}
+
+/// Return true if the call is a heap allocator/reallocator
+//@{
+/// note that these two functions are not suppose to be used externally
+inline bool isHeapAllocExtFunViaRet(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_alloc(fun)
+                   || ExtAPI::getExtAPI()->is_realloc(fun));
+}
+
+inline bool isHeapAllocExtFunViaArg(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->is_arg_alloc(fun);
+}
+
+/// Get the position of argument that holds an allocated heap object.
+//@{
+inline int getHeapAllocHoldingArgPosition(const SVFFunction* fun)
+{
+    return ExtAPI::getExtAPI()->get_alloc_arg_pos(fun);
+}
+
+/// Return true if the call is a heap reallocator
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isReallocExtFun(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
+}
+
+/// Return true if the call is a heap dealloc or not
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isDeallocExtFun(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_dealloc(fun));
+}
+
+/// Return true if the call is a static global call
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isStaticExtFun(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->has_static(fun);
+}
+
+/// Return external call type
+inline ExtAPI::extf_t extCallTy(const SVFFunction* fun)
+{
+    return ExtAPI::getExtAPI()->get_type(fun);
+}
+
+/// Program entry function e.g. main
+//@{
+/// Return true if this is a program entry function (e.g. main)
+inline bool isProgEntryFunction (const SVFFunction * fun)
+{
+    return fun && fun->getName() == "main";
+}
+
+
+/// Get program entry function from module.
+inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
+{
+    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
+    {
+        const SVFFunction *fun = *it;
+        if (fun->getName()==funName)
+            return fun;
+    }
+    return nullptr;
+}
+
+/// Get program entry function from module.
+inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
+{
+    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
+    {
+        const SVFFunction *fun = *it;
+        if (isProgEntryFunction(fun))
+            return (fun);
+    }
+    return nullptr;
+}
+
+/// Return true if this is a program exit function call
+//@{
+inline bool isProgExitFunction (const SVFFunction * fun)
+{
+    return fun && (fun->getName() == "exit" ||
+                   fun->getName() == "__assert_rtn" ||
+                   fun->getName() == "__assert_fail" );
+}
+
+/// Return true if the value refers to constant data, e.g., i32 0
+inline bool isConstantData(const Value* val)
+{
+    return SVFUtil::isa<ConstantData>(val)
+           || SVFUtil::isa<ConstantAggregate>(val)
+           || SVFUtil::isa<MetadataAsValue>(val)
+           || SVFUtil::isa<BlockAddress>(val);
+}
+
+/// Return thread fork function
+//@{
+inline const Value* getForkedFun(const CallSite cs)
+{
+    return ThreadAPI::getThreadAPI()->getForkedFun(cs);
+}
+inline const Value* getForkedFun(const Instruction *inst)
+{
+    return ThreadAPI::getThreadAPI()->getForkedFun(inst);
+}
+//@}
+
+const std::string type2String(const Type* type);
+
 } // End namespace SVFUtil
 
 } // End namespace SVF

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

@@ -1,4 +1,4 @@
-//===----- CFGNormalizer.h -- CFL Alias Analysis Client--------------//
+//===----- CFGNormalizer.h -- Context Free Grammar Normalizer--------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -43,40 +43,33 @@ class CFGNormalizer
 {
 
 public:
-    typedef u32_t Symbol;
-    typedef std::vector<Symbol> Production;
-    typedef Set<Production> Productions;
-
     CFGNormalizer()
     {
     }
 
-    /// Start Normalize (BIN Only)
-    // TODO: Add different Combination Transformation Option
-
-    /// Normalization without attribute expanded
+    /// Normalization with attribute expanded
     CFLGrammar* normalize(GrammarBase *generalGrammar);
 
     /// Fill Every attribute in CFL grammar
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>> *kind2AttrMap);
+    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap);
 
 private:
     /// Add nonterminal to tranfer long rules to binary rules
-    void ebnf_bin(GrammarBase *generalGrammar, CFLGrammar *grammar);
+    void ebnf_bin(CFLGrammar *grammar);
 
-    void ebnf_sign_replace(char sign, GrammarBase* generalGrammar, CFLGrammar *grammar);
+    void ebnf_sign_replace(char sign, CFLGrammar *grammar);
 
-    void insertToCFLGrammar(CFLGrammar *grammar, Production &prod);
+    void insertToCFLGrammar(CFLGrammar *grammar, GrammarBase::Production &prod);
 
-    int ebnf_bracket_match(Production& prod, int i, CFLGrammar *grammar) ;
+    int ebnf_bracket_match(GrammarBase::Production& prod, int i, CFLGrammar *grammar) ;
 
-    int check_head(Map<Symbol, Productions>& grammar, Production& rule);
+    int check_head(Map<GrammarBase::Symbol, GrammarBase::Productions>& grammar, GrammarBase::Production& rule);
 
-    Production strTrans(std::string strPro, CFLGrammar *grammar);
+    GrammarBase::Production strTrans(std::string strPro, CFLGrammar *grammar);
 
-    Production getFilledProd(Production &prod, CFLGrammar::Attribute attribute, CFLGrammar *grammar);
+    GrammarBase::Production getFilledProd(GrammarBase::Production &prod, CFLGrammar::Attribute attribute, CFLGrammar *grammar);
 
-    Productions getFilledProductions(Production &prod, Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> *kind2AttriMap, CFLGrammar *grammar);
+    GrammarBase::Productions getFilledProductions(GrammarBase::Production &prod,const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttriMap, CFLGrammar *grammar);
 };
 
 } // End namespace SVF

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

@@ -70,21 +70,22 @@ public:
             Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep_i", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar_i", 10},{"Vgepbar", 11}};
             GrammarBase *generalGrammar = gReader.build(ConstMap);
             ConstraintGraph *consCG = new ConstraintGraph(svfir);
-            graph = cflGraphBuilder.buildBigraph(consCG);
-            cflChecker.check(generalGrammar, graph);
+            graph = cflGraphBuilder.buildBigraph(consCG, generalGrammar->getStartKind());
+            cflChecker.check(generalGrammar, &cflGraphBuilder, graph);
             grammar = normalizer.normalize(generalGrammar);
-            cflChecker.check(grammar, graph);
+            cflChecker.check(grammar, &cflGraphBuilder, graph);
+            svfir->dump("SVFIR");
+            grammar->dump();
             delete consCG;
             delete generalGrammar;
-            grammar->dump();
         }
         else
         {
             GrammarBase *generalGrammar = gReader.build();
             graph = cflGraphBuilder.buildFromDot(Options::InputFilename, generalGrammar);
-            cflChecker.check(generalGrammar, graph);
+            cflChecker.check(generalGrammar, &cflGraphBuilder, graph);
             grammar = normalizer.normalize(generalGrammar);
-            cflChecker.check(grammar, graph);
+            cflChecker.check(grammar, &cflGraphBuilder, graph);
             delete generalGrammar;
         }
         solver = new CFLSolver(graph, grammar);
@@ -106,7 +107,7 @@ public:
     /// Interface exposed to users of our pointer analysis, given PAGNodeID
     virtual AliasResult alias(NodeID node1, NodeID node2)
     {
-        if(graph->hasEdge(graph->getGNode(node1), graph->getGNode(node2), graph->startSymbol))
+        if(graph->hasEdge(graph->getGNode(node1), graph->getGNode(node2), graph->startKind))
             return AliasResult::MayAlias;
         else
             return AliasResult::NoAlias;

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

@@ -1,4 +1,4 @@
-//===----- CFLGramGraphChecker.h -- CFL Checker for Grammar and Graph alignment --------------//
+//===----- CFLGramGraphChecker.h -- CFL Checker for Grammar and graphBuilder alignment --------------//
 //
 //                     SVF: Static Value-Flow Analysis
 //
@@ -35,28 +35,35 @@ namespace SVF
 class CFLGramGraphChecker
 {
 public:
-    void check(GrammarBase *grammar, CFLGraph *graph)
+    void check(GrammarBase *grammar, CFLGraphBuilder *graphBuilder, CFLGraph *graph)
     {
-        /// Check all the symbol in grammar in graph With the same label
-        for(auto pairV : grammar->terminals)
+        /// Check all kinds in grammar in graphBuilder with the same label
+        for(auto pairV : grammar->getTerminals())
         {
-            if (graph->label2SymMap.find(pairV.first) != graph->label2SymMap.end())
+            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
             {
-                assert(graph->label2SymMap[pairV.first] == pairV.second);
+                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
             }
         }
 
-        for(auto pairV : grammar->nonterminals)
+        for(auto pairV : grammar->getNonterminals())
         {
-            if (graph->label2SymMap.find(pairV.first) != graph->label2SymMap.end())
+            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
             {
-                assert(graph->label2SymMap[pairV.first] == pairV.second);
+                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+            }
+            else
+            {
+                graphBuilder->getLabel2KindMap().insert(std::make_pair (pairV.first,pairV.second));
+                graphBuilder->getKind2LabelMap().insert(std::make_pair (pairV.second, pairV.first));
             }
         }
 
-        /// Get Kind2Attr Map from Graph to Grammar
-        grammar->kind2AttrMap = graph->kind2AttrMap;
-        graph->startSymbol = grammar->startSymbol;
+        /// Get Kind2Attrs Map from Graph to Grammar
+        grammar->setKind2AttrsMap(graphBuilder->getKind2AttrsMap());
+        graph->startKind = grammar->getStartKind();
     }
 };
 

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

@@ -40,17 +40,66 @@ public:
     typedef Set<Production> Productions;
     typedef u32_t Attribute;
     typedef u32_t Kind;
-    Map<std::string, Symbol> terminals;
-    Map<std::string, Symbol> nonterminals;
-    Symbol startSymbol;
-    Symbol totalSymbol;
-    Map<Symbol, Productions> rawProductions;
-    Set<Symbol> attributeSymbol;
-    Map<Kind,  Set<Attribute>> kind2AttrMap;
 
-    Symbol str2Sym(std::string str) const;
+    inline Map<std::string, Kind>& getNonterminals()
+    {
+        return this->nonterminals;
+    }
+
+    inline void setNonterminals(Map<std::string, Kind>& nonterminals)
+    {
+        this->nonterminals = nonterminals;
+    }
 
-    std::string sym2Str(Symbol sym) const;
+    inline Map<std::string, Kind>& getTerminals()
+    {
+        return this->terminals;
+    }
+
+    inline void setTerminals(Map<std::string, Kind>& terminals)
+    {
+        this->terminals = terminals;
+    }
+
+    inline Map<Symbol, Productions>& getRawProductions()
+    {
+        return this->rawProductions;
+    }
+
+    inline const Map<Kind,  Set<Attribute>>& getKind2AttrsMap() const
+    {
+        return this->kind2AttrsMap;
+    }
+
+    inline Kind getTotalKind()
+    {
+        return this->totalKind;
+    }
+
+    inline Kind getStartKind()
+    {
+        return this->startKind;
+    }
+
+    inline void setStartKind(Kind startKind)
+    {
+        this->startKind = startKind;
+    }
+
+    inline void setTotalKind(Kind totalKind)
+    {
+        this->totalKind = totalKind;
+    }
+
+    void setRawProductions(Map<Symbol, Productions>& rawProductions);
+
+    void setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap);
+
+    void setAttributeKinds(const Set<Kind>& attributeKind);
+
+    Kind str2Kind(std::string str) const;
+
+    std::string kind2Str(Kind kind) const;
 
     std::string sym2StrDump(Symbol sym) const;
 
@@ -59,14 +108,14 @@ public:
         return prod.at(pos);
     }
 
-    inline Set<Symbol>& getAttrSyms()
+    inline const Set<Symbol>& getAttrSyms() const
     {
-        return this->attributeSymbol;
+        return this->attributeKinds;
     }
 
-    Symbol insertTerminalSymbol(std::string strLit);
-    Symbol insertNonTerminalSymbol(std::string strLit);
-    void insertAttribute(Symbol s);
+    Kind insertTerminalKind(std::string strLit);
+    Kind insertNonTerminalKind(std::string strLit);
+    void insertAttribute(Kind kind, Attribute a);
 
     inline static Kind getSymKind(Symbol sym)
     {
@@ -86,7 +135,14 @@ public:
 protected:
     static constexpr unsigned char EdgeKindMaskBits = 8;  ///< We use the lower 8 bits to denote edge kind
     static constexpr u64_t EdgeKindMask = (~0ULL) >> (64 - EdgeKindMaskBits);
-
+    Kind startKind;
+private:
+    Set<Kind> attributeKinds;
+    Map<Kind,  Set<Attribute>> kind2AttrsMap;
+    Map<Symbol, Productions> rawProductions;
+    Kind totalKind;
+    Map<std::string, Kind> nonterminals;
+    Map<std::string, Kind> terminals;
 };
 
 class CFLGrammar : public GrammarBase
@@ -127,39 +183,39 @@ public:
         return secondRHS2Prods;
     }
 
-    const bool hasProdsFromFirstRHS(Symbol sym) const
+    const bool hasProdsFromFirstRHS(const Symbol sym) const
     {
         auto it = firstRHS2Prods.find(sym);
         return it!=firstRHS2Prods.end();
     }
 
-    const bool hasProdsFromSingleRHS(Symbol sym) const
+    const bool hasProdsFromSingleRHS(const Symbol sym) const
     {
         auto it = singleRHS2Prods.find(sym);
         return it!=singleRHS2Prods.end();
     }
 
-    const bool hasProdsFromSecondRHS(Symbol sym) const
+    const bool hasProdsFromSecondRHS(const Symbol sym) const
     {
         auto it = secondRHS2Prods.find(sym);
         return it!=secondRHS2Prods.end();
     }
 
-    const Productions& getProdsFromSingleRHS(Symbol sym) const
+    const Productions& getProdsFromSingleRHS(const 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(const 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(const Symbol sym) const
     {
         auto it = secondRHS2Prods.find(sym);
         assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
@@ -167,22 +223,22 @@ public:
     }
 
 
-    const Symbol& getLHSSymbol(const Production& prod)
+    const Symbol& getLHSSymbol(const Production& prod) const
     {
         return prod.at(0);
     }
 
-    const Symbol& getFirstRHSSymbol(const Production& prod)
+    const Symbol& getFirstRHSSymbol(const Production& prod) const
     {
         return prod.at(1);
     }
 
-    const Symbol& getSecondRHSSymbol(const Production& prod)
+    const Symbol& getSecondRHSSymbol(const Production& prod) const
     {
         return prod.at(2);
     }
 
-    void dump();
+    void dump() const;
 
     const inline int num_generator()
     {

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

@@ -1,11 +1,19 @@
 Start:  
    V
 Productions:
+   F -> Addr;
+   F -> Addr ( Copy ) *;
+   F -> Addr ( Store V Load ) *;
    F -> ( Copy ) *;
    F -> ( Store V Load ) *;
+   Fbar -> Addrbar;
+   Fbar -> Addrbar ( Copybar ) *;
+   Fbar -> Addrbar ( Loadbar V Storebar ) *;
    Fbar -> ( Copybar ) *;
    Fbar -> ( Loadbar V Storebar ) *;
    V -> Fbar V F;
    V -> Gepbar_i V Gep_i;
    V -> Addrbar Addr;
-   V -> epsilon;
+   V -> epsilon;
+
+   

package/SVF-osx/include/CFL/CFLGrammarDev.txt

@@ -0,0 +1,16 @@
+Start:  
+   V
+Productions:
+   F -> ( Copy ) *;
+   F -> ( Store V Load ) *;
+   Fbar -> ( Copybar ) *;
+   Fbar -> ( Loadbar Vbar Storebar ) *;
+   V -> Fbar V F;
+   V -> Gepbar_i V Gep_i;
+   V -> Addrbar Addr;
+   V -> epsilon;
+   Vbar -> Fbar Vbar Fbar;
+   Vbar -> Gepbar_i Vbar Gep_i;
+   Vbar -> Addrbar Addr;
+   Vbar -> epsilon;
+   

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

@@ -39,7 +39,19 @@ namespace SVF
 
 class CFLGraphBuilder
 {
+private:
+    typedef CFLGrammar::Kind Kind;
+    typedef CFLGrammar::Symbol Symbol;
+    Map<std::string, Kind> label2KindMap;
+    Map<Kind, std::string> kind2LabelMap;
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrsMap;
+    bool externMap;
+    Symbol current;
+
 public:
+    /// add attribute to kind2Attribute Map
+    void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
+
     /// Build graph by copying nodes and edges from any graph inherited from GenericGraph
     template<class N, class E>
     void build(GenericGraph<N,E>* graph, CFLGraph* cflGraph)
@@ -61,11 +73,22 @@ public:
 
     /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
     template<class N, class E>
-    CFLGraph* buildBigraph(GenericGraph<N,E>* graph)
+    CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind)
     {
-        CFLGraph *cflGraph = new CFLGraph();
+        CFLGraph *cflGraph = new CFLGraph(startKind);
         Map<std::string, SVF::CFLGraph::Symbol> ConstMap =  {{"Addr",0}, {"Copy", 1},{"Store", 2},{"Load", 3},{"Gep_i", 4},{"Vgep", 5},{"Addrbar",6}, {"Copybar", 7},{"Storebar", 8},{"Loadbar", 9},{"Gepbar_i", 10},{"Vgepbar", 11}};
-        cflGraph->setMap(ConstMap);
+        externMap = true;
+        for(auto pairV : ConstMap)
+        {
+            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            {
+                label2KindMap.insert(pairV);
+            }
+            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            {
+                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+            }
+        }
         for(auto it = graph->begin(); it!= graph->end(); it++)
         {
             CFLNode* node = new CFLNode((*it).first);
@@ -82,23 +105,23 @@ public:
                 if(NormalGepCGEdge::classof(edge))
                 {
                     NormalGepCGEdge *nGepEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(edge);
-                    CFLGrammar::Attribute offset =  nGepEdge->getConstantFieldIdx();
-                    cflGraph->addAttribute(edgeLabel, offset);
-                    edgeLabel = CFLGrammar::getAttributedKind(offset, edgeLabel);
+                    CFLGrammar::Attribute attr =  nGepEdge->getConstantFieldIdx();
+                    addAttribute(edgeLabel, attr);
+                    edgeLabel = CFLGrammar::getAttributedKind(attr, edgeLabel);
                     cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                    std::string key = cflGraph->sym2LabelMap[edge->getEdgeKind()];
+                    std::string key = kind2LabelMap[edge->getEdgeKind()];
                     key.pop_back();
                     key.pop_back();    // _i standsfor attribute variable should place at last
                     key.append("bar_i");   // for example Gep_i should be Gepbar_i, not Gep_ibar
-                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFLGrammar::getAttributedKind(offset, cflGraph->label2SymMap[key]));
-                    cflGraph->addAttribute(cflGraph->label2SymMap[key], offset);
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), CFLGrammar::getAttributedKind(attr, label2KindMap[key]));
+                    addAttribute(label2KindMap[key], attr);
                 }
                 else
                 {
                     cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                    std::string key = cflGraph->sym2LabelMap[edge->getEdgeKind()];
+                    std::string key = kind2LabelMap[edge->getEdgeKind()];
                     key.append("bar");
-                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), cflGraph->label2SymMap[key]);
+                    cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
                 }
             }
         }
@@ -109,6 +132,23 @@ public:
 
     /// Build graph from Dot
     CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
+
+    Map<std::string, Kind>& getLabel2KindMap()
+    {
+        return this->label2KindMap;
+    }
+
+    Map<Kind, std::string>& getKind2LabelMap()
+    {
+        return this->kind2LabelMap;
+    }
+
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKind2AttrsMap()
+    {
+        return this->kind2AttrsMap;
+    }
+
+
 };
 }// SVF
 

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

@@ -50,6 +50,8 @@ public:
 
     ~CFLSolver()
     {
+        delete graph;
+        delete grammar;
     }
 
     /// Start solving

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

@@ -77,16 +77,13 @@ class CFLGraph: public GenericCFLGraphTy
 {
 public:
     typedef CFLGrammar::Symbol Symbol;
+    typedef CFLGrammar::Kind Kind;
     typedef GenericNode<CFLNode,CFLEdge>::GEdgeSetTy CFLEdgeSet;
-    Map<std::string, Symbol> label2SymMap;
-    Map<Symbol, std::string> sym2LabelMap;
-    Symbol startSymbol;
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kind2AttrMap;
-    bool externMap;
-    Symbol current;
-
-    CFLGraph()
+    Kind startKind;
+
+    CFLGraph(Kind kind)
     {
+        startKind = kind;
     }
     ~CFLGraph() override = default;
 
@@ -100,27 +97,6 @@ public:
 
     void view();
 
-    void setMap(Map<std::string, Symbol> &labelMap);
-    /// Set label2Sym from External
-    void setMap(GrammarBase *grammar);
-
-    /// add attribute to kind2Attribute Map
-    void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute)
-    {
-        if(kind2AttrMap.find(kind) == kind2AttrMap.end())
-        {
-            Set<CFLGrammar::Attribute> attrs {attribute};
-            kind2AttrMap.insert(make_pair(kind, attrs));
-        }
-        else
-        {
-            if(kind2AttrMap[kind].find(attribute) == kind2AttrMap[kind].end())
-            {
-                kind2AttrMap[kind].insert(attribute);
-            }
-        }
-    }
-
 private:
     CFLEdgeSet cflEdgeSet;
 

package/SVF-osx/include/SVF-FE/BasicTypes.h

@@ -57,6 +57,7 @@ typedef llvm::ConstantDataSequential ConstantDataSequential;
 typedef llvm::ConstantExpr ConstantExpr;
 typedef llvm::ConstantDataArray ConstantDataArray;
 typedef llvm::ConstantData ConstantData;
+typedef llvm::ConstantArray ConstantArray;
 
 // LLVM Instructions
 typedef llvm::AllocaInst AllocaInst;

package/SVF-osx/include/SVF-FE/Graph2Json.h

@@ -5,7 +5,7 @@
 #include "Graphs/ICFG.h"
 #include "Graphs/ICFGNode.h"
 #include "Graphs/ICFGEdge.h"
-#include "SVF-FE/LLVMUtil.h"
+#include "Util/SVFUtil.h"
 
 namespace SVF
 {

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

@@ -66,14 +66,6 @@ inline bool isBlackholeSym(const Value *val)
 }
 
 
-/// Return true if the call is an external call (external library in function summary table)
-/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
-//@{
-inline bool isExtCall(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_ext(fun);
-}
-
 inline bool isExtCall(const CallSite cs)
 {
     return isExtCall(getCallee(cs));
@@ -91,19 +83,6 @@ inline bool isReturn(const Instruction* inst)
     return SVFUtil::isa<ReturnInst>(inst);
 }
 
-/// Return true if the call is a heap allocator/reallocator
-//@{
-/// note that these two functions are not suppose to be used externally
-inline bool isHeapAllocExtFunViaRet(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_alloc(fun)
-                   || ExtAPI::getExtAPI()->is_realloc(fun));
-}
-inline bool isHeapAllocExtFunViaArg(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->is_arg_alloc(fun);
-}
-
 static inline Type *getPtrElementType(const PointerType* pty)
 {
 #if (LLVM_VERSION_MAJOR < 14)
@@ -148,13 +127,6 @@ inline bool isHeapAllocExtCall(const Instruction *inst)
 }
 //@}
 
-/// Get the position of argument that holds an allocated heap object.
-//@{
-inline int getHeapAllocHoldingArgPosition(const SVFFunction* fun)
-{
-    return ExtAPI::getExtAPI()->get_alloc_arg_pos(fun);
-}
-
 inline int getHeapAllocHoldingArgPosition(const CallSite cs)
 {
     return getHeapAllocHoldingArgPosition(getCallee(cs));
@@ -166,14 +138,6 @@ inline int getHeapAllocHoldingArgPosition(const Instruction *inst)
 }
 //@}
 
-/// Return true if the call is a heap reallocator
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isReallocExtFun(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
-}
-
 inline bool isReallocExtCall(const CallSite cs)
 {
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
@@ -187,14 +151,6 @@ inline bool isReallocExtCall(const Instruction *inst)
 }
 //@}
 
-/// Return true if the call is a heap dealloc or not
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isDeallocExtFun(const SVFFunction* fun)
-{
-    return fun && (ExtAPI::getExtAPI()->is_dealloc(fun));
-}
-
 inline bool isDeallocExtCall(const CallSite cs)
 {
     return isDeallocExtFun(getCallee(cs));
@@ -206,15 +162,6 @@ inline bool isDeallocExtCall(const Instruction *inst)
 }
 //@}
 
-
-/// Return true if the call is a static global call
-//@{
-/// note that this function is not suppose to be used externally
-inline bool isStaticExtFun(const SVFFunction* fun)
-{
-    return fun && ExtAPI::getExtAPI()->has_static(fun);
-}
-
 inline bool isStaticExtCall(const CallSite cs)
 {
     bool isPtrTy = cs.getInstruction()->getType()->isPointerTy();
@@ -241,12 +188,6 @@ inline bool isHeapAllocOrStaticExtCall(const Instruction *inst)
 }
 //@}
 
-/// Return external call type
-inline ExtAPI::extf_t extCallTy(const SVFFunction* fun)
-{
-    return ExtAPI::getExtAPI()->get_type(fun);
-}
-
 /// Get the reference type of heap/static object from an allocation site.
 //@{
 inline const PointerType *getRefTypeOfHeapAllocOrStatic(const CallSite cs)
@@ -362,18 +303,6 @@ inline bool isBarrierWaitCall(const Instruction *inst)
 }
 //@}
 
-/// Return thread fork function
-//@{
-inline const Value* getForkedFun(const CallSite cs)
-{
-    return ThreadAPI::getThreadAPI()->getForkedFun(cs);
-}
-inline const Value* getForkedFun(const Instruction *inst)
-{
-    return ThreadAPI::getThreadAPI()->getForkedFun(inst);
-}
-//@}
-
 /// Return sole argument of the thread routine
 //@{
 inline const Value* getActualParmAtForkSite(const CallSite cs)
@@ -413,15 +342,6 @@ inline const Value* getTaskDataAtHareParForSite(const Instruction *inst)
 /// Return true if this value refers to a object
 bool isObject (const Value * ref);
 
-/// Return true if the value refers to constant data, e.g., i32 0
-inline bool isConstantData(const Value* val)
-{
-    return SVFUtil::isa<ConstantData>(val)
-           || SVFUtil::isa<ConstantAggregate>(val)
-           || SVFUtil::isa<MetadataAsValue>(val)
-           || SVFUtil::isa<BlockAddress>(val);
-}
-
 /// Method for dead function, which does not have any possible caller
 /// function address is not taken and never be used in call or invoke instruction
 //@{
@@ -436,43 +356,11 @@ inline bool ArgInDeadFunction (const Value * val)
 }
 //@}
 
-/// Program entry function e.g. main
-//@{
-/// Return true if this is a program entry function (e.g. main)
-inline bool isProgEntryFunction (const SVFFunction * fun)
-{
-    return fun && fun->getName() == "main";
-}
-
 inline bool isProgEntryFunction (const Function * fun)
 {
     return fun && fun->getName() == "main";
 }
 
-/// Get program entry function from module.
-inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (fun->getName()==funName)
-            return fun;
-    }
-    return nullptr;
-}
-
-/// Get program entry function from module.
-inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
-{
-    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
-    {
-        const SVFFunction *fun = *it;
-        if (isProgEntryFunction(fun))
-            return (fun);
-    }
-    return nullptr;
-}
-
 /// Return true if this is an argument of a program entry function (e.g. main)
 inline bool ArgInProgEntryFunction (const Value * val)
 {
@@ -483,15 +371,6 @@ inline bool ArgInProgEntryFunction (const Value * val)
 bool isPtrInDeadFunction (const Value * value);
 //@}
 
-/// Return true if this is a program exit function call
-//@{
-inline bool isProgExitFunction (const SVFFunction * fun)
-{
-    return fun && (fun->getName() == "exit" ||
-                   fun->getName() == "__assert_rtn" ||
-                   fun->getName() == "__assert_fail" );
-}
-
 inline bool isProgExitCall(const CallSite cs)
 {
     return isProgExitFunction(getCallee(cs));
@@ -677,7 +556,6 @@ u32_t getTypeSizeInBytes(const Type* type);
 u32_t getTypeSizeInBytes(const StructType *sty, u32_t field_index);
 //@}
 
-const std::string type2String(const Type* type);
 
 } // End namespace SVFUtil
 

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

@@ -94,7 +94,6 @@ typedef llvm::Argument Argument;
 typedef llvm::Constant Constant;
 typedef llvm::ConstantInt ConstantInt;
 typedef llvm::ConstantPointerNull ConstantPointerNull;
-typedef llvm::ConstantArray ConstantArray;
 typedef llvm::GlobalAlias GlobalAlias;
 
 /// LLVM metadata

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

@@ -352,6 +352,130 @@ bool startAnalysisLimitTimer(unsigned timeLimit);
 /// timer or not (return value of startLimitTimer).
 void stopAnalysisLimitTimer(bool limitTimerSet);
 
+/// Return true if the call is an external call (external library in function summary table)
+/// If the libary function is redefined in the application code (e.g., memcpy), it will return false and will not be treated as an external call.
+//@{
+inline bool isExtCall(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->is_ext(fun);
+}
+
+/// Return true if the call is a heap allocator/reallocator
+//@{
+/// note that these two functions are not suppose to be used externally
+inline bool isHeapAllocExtFunViaRet(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_alloc(fun)
+                   || ExtAPI::getExtAPI()->is_realloc(fun));
+}
+
+inline bool isHeapAllocExtFunViaArg(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->is_arg_alloc(fun);
+}
+
+/// Get the position of argument that holds an allocated heap object.
+//@{
+inline int getHeapAllocHoldingArgPosition(const SVFFunction* fun)
+{
+    return ExtAPI::getExtAPI()->get_alloc_arg_pos(fun);
+}
+
+/// Return true if the call is a heap reallocator
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isReallocExtFun(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_realloc(fun));
+}
+
+/// Return true if the call is a heap dealloc or not
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isDeallocExtFun(const SVFFunction* fun)
+{
+    return fun && (ExtAPI::getExtAPI()->is_dealloc(fun));
+}
+
+/// Return true if the call is a static global call
+//@{
+/// note that this function is not suppose to be used externally
+inline bool isStaticExtFun(const SVFFunction* fun)
+{
+    return fun && ExtAPI::getExtAPI()->has_static(fun);
+}
+
+/// Return external call type
+inline ExtAPI::extf_t extCallTy(const SVFFunction* fun)
+{
+    return ExtAPI::getExtAPI()->get_type(fun);
+}
+
+/// Program entry function e.g. main
+//@{
+/// Return true if this is a program entry function (e.g. main)
+inline bool isProgEntryFunction (const SVFFunction * fun)
+{
+    return fun && fun->getName() == "main";
+}
+
+
+/// Get program entry function from module.
+inline const SVFFunction* getProgFunction(SVFModule* svfModule, const std::string& funName)
+{
+    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
+    {
+        const SVFFunction *fun = *it;
+        if (fun->getName()==funName)
+            return fun;
+    }
+    return nullptr;
+}
+
+/// Get program entry function from module.
+inline const SVFFunction* getProgEntryFunction(SVFModule* svfModule)
+{
+    for (SVFModule::const_iterator it = svfModule->begin(), eit = svfModule->end(); it != eit; ++it)
+    {
+        const SVFFunction *fun = *it;
+        if (isProgEntryFunction(fun))
+            return (fun);
+    }
+    return nullptr;
+}
+
+/// Return true if this is a program exit function call
+//@{
+inline bool isProgExitFunction (const SVFFunction * fun)
+{
+    return fun && (fun->getName() == "exit" ||
+                   fun->getName() == "__assert_rtn" ||
+                   fun->getName() == "__assert_fail" );
+}
+
+/// Return true if the value refers to constant data, e.g., i32 0
+inline bool isConstantData(const Value* val)
+{
+    return SVFUtil::isa<ConstantData>(val)
+           || SVFUtil::isa<ConstantAggregate>(val)
+           || SVFUtil::isa<MetadataAsValue>(val)
+           || SVFUtil::isa<BlockAddress>(val);
+}
+
+/// Return thread fork function
+//@{
+inline const Value* getForkedFun(const CallSite cs)
+{
+    return ThreadAPI::getThreadAPI()->getForkedFun(cs);
+}
+inline const Value* getForkedFun(const Instruction *inst)
+{
+    return ThreadAPI::getThreadAPI()->getForkedFun(inst);
+}
+//@}
+
+const std::string type2String(const Type* type);
+
 } // End namespace SVFUtil
 
 } // End namespace SVF

package/package.json

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