svf-lib 1.0.1567 → 1.0.1569

package/SVF-linux/svf/include/SVFIR/SVFValue.h

@@ -218,6 +218,10 @@ public:
     {
         return name;
     }
+    inline virtual void setName(const std::string& valueName)
+    {
+        name = valueName;
+    }
 
     inline virtual const SVFType* getType() const
     {
@@ -266,6 +270,7 @@ class SVFFunction : public SVFValue
     friend class LLVMModuleSet;
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
 
 public:
     typedef std::vector<const SVFBasicBlock*>::const_iterator const_iterator;
@@ -482,6 +487,7 @@ class SVFBasicBlock : public SVFValue
     friend class LLVMModuleSet;
     friend class SVFIRWriter;
     friend class SVFIRReader;
+    friend class SVFIRBuilder;
 
 public:
     typedef std::vector<const SVFInstruction*>::const_iterator const_iterator;
@@ -650,6 +656,7 @@ class SVFCallInst : public SVFInstruction
     friend class SVFIRWriter;
     friend class SVFIRReader;
     friend class LLVMModuleSet;
+    friend class SVFIRBuilder;
 
 private:
     std::vector<const SVFValue*> args;

package/SVF-linux/svf/include/Util/ExtAPI.h

@@ -224,38 +224,227 @@ private:
 
 public:
 
-    class Operation
+    enum OperationType
     {
-    public:
-        Operation() {};
-
-        Operation(std::string opn, std::vector<std::string> varstr) : op(opn), operandStr(varstr) {};
+        Addr,
+        Copy,
+        Load,
+        Store,
+        Gep,
+        Call,
+        Return,
+        Rb_tree_ops,
+        Memcpy_like,
+        Memset_like,
+        Other
+    };
 
-        std::string getOperator()
+    class Operand
+    {
+    public:
+        OperationType getType() const
         {
-            return op;
+            return opType;
         }
-
-        std::vector<std::string> getOperandStr()
+        void setType(OperationType type)
         {
-            return operandStr;
+            opType = type;
         }
-
-        std::vector<NodeID> &getOperands()
+        const std::string &getSrcValue() const
+        {
+            return src;
+        }
+        void setSrcValue(const std::string &value)
+        {
+            src = value;
+        }
+        const std::string &getDstValue() const
+        {
+            return dst;
+        }
+        void setDstValue(const std::string &value)
+        {
+            dst = value;
+        }
+        NodeID getSrcID() const
+        {
+            return srcID;
+        }
+        void setSrcID(NodeID id)
+        {
+            srcID = id;
+        }
+        NodeID getDstID() const
+        {
+            return dstID;
+        }
+        void setDstID(NodeID id)
+        {
+            dstID = id;
+        }
+        const std::string &getOffsetOrSizeStr() const
         {
-            return operands;
+            return offsetOrSizeStr;
         }
+        void setOffsetOrSizeStr(const std::string &str)
+        {
+            offsetOrSizeStr = str;
+        }
+        u32_t getOffsetOrSize() const
+        {
+            return offsetOrSize;
+        }
+        void setOffsetOrSize(u32_t off)
+        {
+            offsetOrSize = off;
+        }
+    private:
+        OperationType opType; // 操作数类型
+        std::string src; // 操作数值
+        std::string dst; //
+        std::string offsetOrSizeStr; // Gep
+        NodeID srcID;
+        NodeID dstID;
+        u32_t offsetOrSize;
+    };
 
-        void setOperands(std::vector<NodeID> vars)
+    class ExtOperation
+    {
+    public:
+        bool isCallOp() const
+        {
+            return callOp;
+        }
+        void setCallOp(bool isCall)
+        {
+            callOp = isCall;
+        }
+        bool isConOp() const
+        {
+            return conOp;
+        }
+        void setConOp(bool isCon)
+        {
+            conOp = isCon;
+        }
+        Operand& getBasicOp()
+        {
+            return basicOp;
+        }
+        void setBasicOp(Operand op)
+        {
+            basicOp = op;
+        }
+        const std::string &getCondition() const
+        {
+            return condition;
+        }
+        void setCondition(const std::string &cond)
+        {
+            condition = cond;
+        }
+        std::vector<Operand>& getTrueBranchOperands()
+        {
+            return trueBranch_operands;
+        }
+        void setTrueBranchOperands(std::vector<Operand> tbo)
+        {
+            trueBranch_operands = tbo;
+        }
+        std::vector<Operand>& getFalseBranchOperands()
+        {
+            return falseBranch_operands;
+        }
+        void setFalseBranchOperands(std::vector<Operand> fbo)
+        {
+            falseBranch_operands = fbo;
+        }
+        const std::string &getCalleeName() const
+        {
+            return callee_name;
+        }
+        void setCalleeName(const std::string &name)
+        {
+            callee_name = name;
+        }
+        const std::string &getCalleeReturn() const
+        {
+            return callee_return;
+        }
+        void setCalleeReturn(const std::string &ret)
+        {
+            callee_return = ret;
+        }
+        const std::string &getCalleeArguments() const
+        {
+            return callee_arguments;
+        }
+        void setCalleeArguments(const std::string &args)
+        {
+            callee_arguments = args;
+        }
+        std::vector<Operand>& getCalleeOperands()
         {
-            operands = vars;
+            return callee_operands;
         }
+        void setCalleeOperands(std::vector<Operand> ops)
+        {
+            callee_operands = ops;
+        }
+    private:
+        bool callOp = false;
+        bool conOp = false;
+        Operand basicOp;
+        std::string condition;
+        std::vector<Operand> trueBranch_operands;
+        std::vector<Operand> falseBranch_operands;
+        std::string callee_name;
+        std::string callee_return;
+        std::string callee_arguments;
+        std::vector<Operand> callee_operands;
+    };
 
+    class ExtFunctionOps
+    {
+    public:
+        ExtFunctionOps() {};
+        ExtFunctionOps(const std::string &name, std::vector<ExtOperation> ops) : extFunName(name), extOperations(ops) {};
+        const std::string &getExtFunName() const
+        {
+            return extFunName;
+        }
+        void setExtFunName(const std::string &name)
+        {
+            extFunName = name;
+        }
+        std::vector<ExtOperation>& getOperations()
+        {
+            return extOperations;
+        }
+        void setOperations(std::vector<ExtOperation> ops)
+        {
+            extOperations = ops;
+        }
+        u32_t getCallStmtNum()
+        {
+            return callStmtNum;
+        }
+        void setCallStmtNum(u32_t num)
+        {
+            callStmtNum = num;
+        }
     private:
-        std::string op;
-        std::vector<std::string> operandStr;
-        std::vector<NodeID> operands;
+        std::string extFunName;
+        std::vector<ExtOperation> extOperations;
+        u32_t callStmtNum = 0;
     };
+
+private:
+    // Map an external function to its operations
+    std::map<std::string, ExtFunctionOps> extFunToOps;
+
+public:
+
     static ExtAPI *getExtAPI(const std::string& = "");
 
     static void destory();
@@ -291,7 +480,8 @@ public:
     cJSON *get_FunJson(const std::string &funName);
 
     // Get all operations of an extern function
-    std::vector<Operation> getAllOperations(std::string funName);
+    Operand getBasicOperation(cJSON* obj);
+    ExtFunctionOps getExtFunctionOps(std::string funName);
 
     // Get property of the operation, e.g. "EFT_A1R_A0R"
     extType get_type(const SVF::SVFFunction *callee);

package/SVF-linux/svf/include/Util/ExtAPI.json

@@ -4990,35 +4990,55 @@
         "arguments":  "(i8*, i8, i32, i32, i1)",
         "type": "EFT_L_A0__A0R_A1",
         "overwrite_app_function": 0,
-        "memset_like": ["Arg0", "Arg1", "Arg2"]
+        "memset_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        }
     },
     "llvm.memset.p0i8.i32": {
         "return":  "void",
         "arguments":  "(i8*, i8, i32, i32, i1)",
         "type": "EFT_L_A0__A0R_A1",
         "overwrite_app_function": 0,
-        "memset_like": ["Arg0", "Arg1", "Arg2"]
+        "memset_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        }
     },
     "llvm.memset.p0i8.i64": {
         "return":  "void",
         "arguments":  "(i8*, i8, i64, i32, i1)",
         "type": "EFT_L_A0__A0R_A1",
         "overwrite_app_function": 0,
-        "memset_like": ["Arg0", "Arg1", "Arg2"]
+        "memset_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        }
     },
     "__memset_chk": {
         "return":  "void *",
         "arguments":  "(void *, int, size_t, size_t)",
         "type": "EFT_L_A0__A0R_A1",
         "overwrite_app_function": 0,
-        "memset_like": ["Arg0", "Arg1", "Arg2"]
+        "memset_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        }
     },
     "llvm.memcpy":  {
         "return":  "void",
         "arguments":  "(i8*, i8*, i32, i32, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5029,7 +5049,11 @@
         "arguments":  "(i8*, i8*, i32, i32, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5040,7 +5064,11 @@
         "arguments":  "(i8*, *i8, i64, i32, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5051,7 +5079,11 @@
         "arguments":  "(i8*, i8*, i32, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5062,7 +5094,11 @@
         "arguments":  "(i8*, i8*, i32, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5073,7 +5109,11 @@
         "arguments":  "(i8*, i8*, i64, i1)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5084,7 +5124,11 @@
         "arguments":  "(void *restrict, const void *restrict, int, size_t)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5095,7 +5139,11 @@
         "arguments":  "(void *, const void *, size_t)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5106,7 +5154,11 @@
         "arguments":  "(void *, const void *, size_t)",
         "type": "EFT_L_A0__A0R_A1R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5117,14 +5169,21 @@
         "arguments":  "(const void *, void *, size_t)",
         "type": "EFT_A1R_A0R",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg1", "Arg0", "Arg2"]
+        "memcpy_like":  {
+            "src": "Arg1",
+            "dst": "Arg0",
+            "size": "Arg2"
+        }
     },
     "iconv":    {
         "return":  "size_t",
         "arguments":  "(iconv_t, char **restrict, size_t *restrict, char **restrict, size_t *restrict)",
         "type": "EFT_A3R_A1R_NS",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg3", "Arg1"]
+        "memcpy_like":  {
+            "src": "Arg3",
+            "dst": "Arg1"
+        }
     },
     "strtod":   {
         "return":  "double",
@@ -5201,7 +5260,11 @@
         "arguments":  "(char *, const char *, size_t)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5212,7 +5275,11 @@
         "arguments":  "(char *, const char *, size_t)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5223,7 +5290,10 @@
         "arguments":  "(char *restrict, const char *restrict)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5234,7 +5304,10 @@
         "arguments":  "(char *, char *)", 
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5245,7 +5318,10 @@
         "arguments":  "(char *, const char *)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5256,7 +5332,11 @@
         "arguments":  "(char *, const char *, size_t)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5267,7 +5347,11 @@
         "arguments":  "(char *, const char *, size_t)",
         "type": "EFT_L_A0__A1_A0",
         "overwrite_app_function": 0,
-        "memcpy_like":  ["Arg0", "Arg1", "Arg2"],
+        "memcpy_like":  {
+            "src": "Arg0",
+            "dst": "Arg1",
+            "size": "Arg2"
+        },
         "CopyStmt": {
 			"src": "Arg0",
 			"dst": "Ret"
@@ -5726,5 +5810,24 @@
             "src": "NullPtr",
             "dst": "Dummy"
         }
+    },
+    "swapExtCallStmt":{
+        "return":  "void",
+        "arguments":  "(char **, char **)",
+        "type": "EFT_NOOP",
+        "overwrite_app_function": 0,
+        "CallStmt": {
+            "callee_name": "swap",
+            "callee_return": "void",
+            "callee_arguments": "(char **, char **)",
+            "CopyStmt1": {
+                "src": "swapExtCallStmt_Arg0",
+                "dst": "swap_Arg0"
+            },
+            "CopyStmt2": {
+                "src": "swapExtCallStmt_Arg1",
+                "dst": "swap_Arg1"
+            }
+        }
     }
 }

package/SVF-linux/svf-llvm/include/SVF-LLVM/LLVMModule.h

@@ -42,6 +42,7 @@ class SymbolTableInfo;
 
 class LLVMModuleSet
 {
+    friend class SVFIRBuilder;
 
 public:
 

package/SVF-linux/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h

@@ -224,9 +224,6 @@ protected:
     /// Get the base value of (i8* src and i8* dst) for external argument (e.g. memcpy(i8* dst, i8* src, int size))
     const Value* getBaseValueForExtArg(const Value* V);
 
-    /// Get the base type and max offset
-    const Type* getBaseTypeAndFlattenedFields(const Value* V, std::vector<LocationSet> &fields, const Value* sz);
-
     /// Handle direct call
     void handleDirectCall(CallBase* cs, const Function *F);
 
@@ -235,9 +232,17 @@ protected:
 
     /// Handle external call
     //@{
-    virtual void parseOperations(std::vector<ExtAPI::Operation>  &operations, const SVFCallInst* svfcall);
+    virtual SVFCallInst* addSVFExtCallInst(const SVFCallInst* svfInst, SVFBasicBlock* svfBB, const SVFFunction* svfCaller, const SVFFunction* svfCallee);
+    virtual void addSVFExtRetInst(SVFCallInst* svfCall, SVFBasicBlock* svfBB, SVFFunction* svfCaller);
+    virtual SVFInstruction* addSVFExtInst(const std::string& instName, const SVFCallInst* svfInst, SVFBasicBlock* svfBB, SVF::ExtAPI::OperationType opType, const SVFType* svfType);
+    virtual void extFuncAtomaticOperation(ExtAPI::Operand& atomicOp, const SVFCallInst* svfInst);
+    virtual SVFBasicBlock* extFuncInitialization(const SVFCallInst* svfInst, SVFFunction* svfCaller);
+    virtual void handleExtCallStat(ExtAPI::ExtFunctionOps &extFunctionOps, const SVFCallInst* svfInst);
+    virtual NodeID getExtID(ExtAPI::OperationType operationType, const std::string &s, const SVFCallInst* svfCall);
+    virtual void parseAtomaticOp(SVF::ExtAPI::Operand &atomaticOp, const SVFCallInst* svfCall, std::map<std::string, NodeID> &nodeIDMap);
+    virtual void parseExtFunctionOps(ExtAPI::ExtFunctionOps &extFunctionOps, const SVFCallInst* svfCall);
     virtual void preProcessExtCall(CallBase* cs);
-    virtual void handleExtCall(SVFInstruction* svfinst, const SVFFunction* svfcallee);
+    virtual void handleExtCall(const SVFInstruction* svfInst, const SVFFunction* svfCallee);
     void addComplexConsForExt(const SVFValue* D, const SVFValue* S, const SVFValue* sz);
     //@}
 

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

@@ -56,7 +56,7 @@ public:
     CFLGrammar* normalize(GrammarBase *generalGrammar);
 
     /// Expand every variable attribute in rawProductions of grammarbase
-    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kind2AttrsMap);
+    CFLGrammar* fillAttribute(CFLGrammar *grammar, const Map<CFLGrammar::Kind, Set<CFLGrammar::Attribute>>& kindToAttrsMap);
 
 private:
     /// Add nonterminal to tranfer long rules to binary rules

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

@@ -112,8 +112,8 @@ public:
         {
             return false;
         }
-        CFLGrammar::Kind copyKind = grammar->str2Kind("copy");
-        CFLGrammar::Kind copybarKind = grammar->str2Kind("copybar");
+        CFLGrammar::Kind copyKind = grammar->strToKind("copy");
+        CFLGrammar::Kind copybarKind = grammar->strToKind("copybar");
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(src),graph->getGNode(dst), copyKind));
         solver->pushIntoWorklist(graph->addCFLEdge(graph->getGNode(dst),graph->getGNode(src), copybarKind));
         return true;

package/SVF-osx/svf/include/CFL/CFLBase.h

@@ -61,6 +61,9 @@ public:
         delete grammarBase;
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Build Grammar from text file
     virtual void buildCFLGrammar();
 

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

@@ -42,29 +42,29 @@ public:
         /// Check all kinds in grammar in graphBuilder with the same label
         for(auto pairV : grammar->getTerminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[pairV.second] == pairV.first);
             }
         }
 
         for(auto pairV : grammar->getNonterminals())
         {
-            if (graphBuilder->getLabel2KindMap().find(pairV.first) != graphBuilder->getLabel2KindMap().end())
+            if (graphBuilder->getLabelToKindMap().find(pairV.first) != graphBuilder->getLabelToKindMap().end())
             {
-                assert(graphBuilder->getLabel2KindMap()[pairV.first] == pairV.second);
-                assert(graphBuilder->getKind2LabelMap()[pairV.second] == pairV.first);
+                assert(graphBuilder->getLabelToKindMap()[pairV.first] == pairV.second);
+                assert(graphBuilder->getKindToLabelMap()[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));
+                graphBuilder->getLabelToKindMap().insert(std::make_pair (pairV.first,pairV.second));
+                graphBuilder->getKindToLabelMap().insert(std::make_pair (pairV.second, pairV.first));
             }
         }
 
-        /// Get Kind2Attrs Map from Graph to Grammar
-        grammar->setKind2AttrsMap(graphBuilder->getKind2AttrsMap());
+        /// Get KindToAttrs Map from Graph to Grammar
+        grammar->setKindToAttrsMap(graphBuilder->getKindToAttrsMap());
         graph->startKind = grammar->getStartKind();
     }
 };

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

@@ -192,9 +192,9 @@ public:
         return this->rawProductions;
     }
 
-    inline const Map<Kind,  Set<Attribute>>& getKind2AttrsMap() const
+    inline const Map<Kind,  Set<Attribute>>& getKindToAttrsMap() const
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
     inline Kind getTotalKind()
@@ -223,17 +223,17 @@ public:
 
     void setRawProductions(SymbolMap<Symbol, Productions>& rawProductions);
 
-    void setKind2AttrsMap(const Map<Kind,  Set<Attribute>>& kind2AttrsMap);
+    void setKindToAttrsMap(const Map<Kind,  Set<Attribute>>& kindToAttrsMap);
 
     void setAttributeKinds(const Set<Kind>& attributeKind);
 
-    Kind str2Kind(std::string str) const;
+    Kind strToKind(std::string str) const;
 
-    Symbol str2Symbol(const std::string str) const;
+    Symbol strToSymbol(const std::string str) const;
 
-    std::string kind2Str(Kind kind) const;
+    std::string kindToStr(Kind kind) const;
 
-    std::string sym2StrDump(Symbol sym) const;
+    std::string symToStrDump(Symbol sym) const;
 
     Symbol getSymbol(const Production& prod, u32_t pos)
     {
@@ -282,7 +282,7 @@ private:
     Map<std::string, Kind> terminals;
     Map<std::string, Kind> EBNFSigns; /// Map contains Signs' String and associated Symbols
     Set<Kind> attributeKinds;
-    Map<Kind,  Set<Attribute>> kind2AttrsMap;
+    Map<Kind,  Set<Attribute>> kindToAttrsMap;
     SymbolMap<Symbol, Productions> rawProductions;
     u32_t totalKind;
 };
@@ -310,57 +310,57 @@ public:
         return epsilonProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSingleRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSingleRHSToProds()
     {
-        return singleRHS2Prods;
+        return singleRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getFirstRHS2Prods()
+    SymbolMap<Symbol, Productions>& getFirstRHSToProds()
     {
-        return firstRHS2Prods;
+        return firstRHSToProds;
     }
 
-    SymbolMap<Symbol, Productions>& getSecondRHS2Prods()
+    SymbolMap<Symbol, Productions>& getSecondRHSToProds()
     {
-        return secondRHS2Prods;
+        return secondRHSToProds;
     }
 
     const bool hasProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        return it!=firstRHS2Prods.end();
+        auto it = firstRHSToProds.find(sym);
+        return it!=firstRHSToProds.end();
     }
 
     const bool hasProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        return it!=singleRHS2Prods.end();
+        auto it = singleRHSToProds.find(sym);
+        return it!=singleRHSToProds.end();
     }
 
     const bool hasProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        return it!=secondRHS2Prods.end();
+        auto it = secondRHSToProds.find(sym);
+        return it!=secondRHSToProds.end();
     }
 
     const Productions& getProdsFromSingleRHS(const Symbol sym) const
     {
-        auto it = singleRHS2Prods.find(sym);
-        assert(it!=singleRHS2Prods.end() && "production (X -> sym) not found for sym!!");
+        auto it = singleRHSToProds.find(sym);
+        assert(it!=singleRHSToProds.end() && "production (X -> sym) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromFirstRHS(const Symbol sym) const
     {
-        auto it = firstRHS2Prods.find(sym);
-        assert(it!=firstRHS2Prods.end() && "production (X -> sym Y ) not found for sym!!");
+        auto it = firstRHSToProds.find(sym);
+        assert(it!=firstRHSToProds.end() && "production (X -> sym Y ) not found for sym!!");
         return it->second;
     }
 
     const Productions& getProdsFromSecondRHS(const Symbol sym) const
     {
-        auto it = secondRHS2Prods.find(sym);
-        assert(it!=secondRHS2Prods.end() && "production (X -> Y sym) not found for sym!!");
+        auto it = secondRHSToProds.find(sym);
+        assert(it!=secondRHSToProds.end() && "production (X -> Y sym) not found for sym!!");
         return it->second;
     }
 
@@ -392,9 +392,9 @@ public:
 
 private:
     SymbolSet<Production> epsilonProds;
-    SymbolMap<Symbol, Productions> singleRHS2Prods;
-    SymbolMap<Symbol, Productions> firstRHS2Prods;
-    SymbolMap<Symbol, Productions> secondRHS2Prods;
+    SymbolMap<Symbol, Productions> singleRHSToProds;
+    SymbolMap<Symbol, Productions> firstRHSToProds;
+    SymbolMap<Symbol, Productions> secondRHSToProds;
     u32_t newTerminalSubscript;
 };
 

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

@@ -37,27 +37,40 @@
 namespace SVF
 {
 
-/*!
- * Build CFLGraph from memory graph or dot form
-
+/**
+ * CFLGraphBuilder class is responsible for building CFL (Context-Free Language) graphs
+ * from text files or dot files or from memory graph.
  */
-
 class CFLGraphBuilder
 {
 protected:
+    /// Define Kind(Not contain attribute) and Symbol(May contain attribute) as types derived from CFLGrammar
+    /// to numerically represent label
     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;
+
+    /// Maps to maintain mapping between labels and kinds
+    Map<std::string, Kind> labelToKindMap;
+    Map<Kind, std::string> kindToLabelMap;
+
+    /// Map to maintain attributes associated with each kind
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>> kindToAttrsMap;
+
     Kind current;
+    CFLGraph *cflGraph;
 
-public:
-    /// add attribute to kind2Attribute Map
+    /// Method to add an attribute to a specific kind
     void addAttribute(CFLGrammar::Kind kind, CFLGrammar::Attribute attribute);
 
-    /// Build graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// build label and kind connect from the grammar
+    void buildlabelToKindMap(GrammarBase *grammar);
+
+    /// add src and dst node from file
+    CFLNode* addGNode(u32_t NodeID);
+
+public:
+    /// Method to build a CFL 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)
     {
@@ -76,32 +89,32 @@ public:
         }
     }
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
+    /// Method to build a bidirectional CFL graph by copying nodes and edges
+    /// from any graph inherited from GenericGraph
     template<class N, class E>
     CFLGraph* buildBigraph(GenericGraph<N,E>* graph, Kind startKind, GrammarBase *grammar)
     {
         CFLGraph *cflGraph = new CFLGraph(startKind);
-        externMap = true;
         for(auto pairV : grammar->getTerminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto pairV : grammar->getNonterminals())
         {
-            if(label2KindMap.find(pairV.first) == label2KindMap.end())
+            if(labelToKindMap.find(pairV.first) == labelToKindMap.end())
             {
-                label2KindMap.insert(pairV);
+                labelToKindMap.insert(pairV);
             }
-            if(kind2LabelMap.find(pairV.second) == kind2LabelMap.end())
+            if(kindToLabelMap.find(pairV.second) == kindToLabelMap.end())
             {
-                kind2LabelMap.insert(make_pair(pairV.second, pairV.first));
+                kindToLabelMap.insert(make_pair(pairV.second, pairV.first));
             }
         }
         for(auto it = graph->begin(); it!= graph->end(); it++)
@@ -116,78 +129,89 @@ public:
             {
                 CFLGrammar::Kind edgeLabel = edge->getEdgeKind();
                 cflGraph->addCFLEdge(cflGraph->getGNode(edge->getSrcID()), cflGraph->getGNode(edge->getDstID()), edgeLabel);
-                std::string key = kind2LabelMap[edge->getEdgeKind()];
+                std::string key = kindToLabelMap[edge->getEdgeKind()];
                 key.append("bar");
-                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), label2KindMap[key]);
+                cflGraph->addCFLEdge(cflGraph->getGNode(edge->getDstID()), cflGraph->getGNode(edge->getSrcID()), labelToKindMap[key]);
             }
         }
         return cflGraph;
     }
 
-    /// Build graph from file
-    void build(std::string filename, CFLGraph* cflGraph);
-
-    /// Build graph from Dot
+    /// Method to build a CFL graph from a Dot file
     CFLGraph *buildFromDot(std::string filename, GrammarBase *grammar);
 
-    Map<std::string, Kind>& getLabel2KindMap()
+    /// Method to build a CFL graph from a Text file
+    CFLGraph* buildFromTextFile(std::string fileName, GrammarBase *grammar);
+
+    /// @{
+    /// Getter methods for accessing class variables
+
+    /// Returns a reference to the map that associates string labels with their corresponding Kind
+    Map<std::string, Kind>& getLabelToKindMap()
     {
-        return this->label2KindMap;
+        return this->labelToKindMap;
     }
 
-    Map<Kind, std::string>& getKind2LabelMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding string labels
+    Map<Kind, std::string>& getKindToLabelMap()
     {
-        return this->kind2LabelMap;
+        return this->kindToLabelMap;
     }
 
-    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKind2AttrsMap()
+    /// Returns a reference to the map that associates Kinds with their corresponding attributes
+    Map<CFLGrammar::Kind,  Set<CFLGrammar::Attribute>>& getKindToAttrsMap()
     {
-        return this->kind2AttrsMap;
+        return this->kindToAttrsMap;
     }
 
-
+    /// @}
 };
 
+/// AliasCFLGraphBuilder: a CFLGraphBuilder specialized for handling aliasing
 class AliasCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from GenericGraph
     CFLGraph* buildBigraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+/// VFCFLGraphBuilder: a CFLGraphBuilder specialized for handling value-flow
 class VFCFLGraphBuilder : public CFLGraphBuilder
 {
 public:
-    /// Build Bidirectional graph by copying nodes and edges from const graph inherited from GenericGraph
+    /// Builds a bidirectional CFL graph by copying nodes and edges from a const graph that inherits from SVFG
     CFLGraph* buildBigraph(SVFG *graph, Kind startKind, GrammarBase *grammar);
 
-    /// Build Bidirectional graph by copying nodes and edges from any graph inherited from GenericGraph
-    /// And transfer Load Store to copy edge and address edge to construct PEG style CFG
+    /// Builds a bidirectional CFL graph by copying nodes and edges from any graph that inherits from GenericGraph
+    /// Transfers Load and Store to copy edge and address edge to construct PEG style CFLGraph
     CFLGraph* buildBiPEGgraph(ConstraintGraph *graph, Kind startKind, GrammarBase *grammar, SVFIR* pag);
 
 private:
+    /// Connects VGep (Variable GEP)
     void connectVGep(CFLGraph *cflGraph,  ConstraintGraph *graph, ConstraintNode *src, ConstraintNode *dst, u32_t level, SVFIR* pag);
 
-    /// Handle edge except for the GEP
+    /// Handles edges, with the exception of the GEP
     void addBiCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Kind label);
 
-    /// Add Bidirectional GEP edge with attribute
+    /// Adds bidirectional GEP edges with attributes
     void addBiGepCFLEdge(CFLGraph *cflGraph,  ConstraintNode* src, ConstraintNode* dst, CFLGrammar::Attribute attri);
 };
 
+
 }// SVF
 
 #endif /* INCLUDE_CFL_CFLGRAPHBUILDER_H_*/

package/SVF-osx/svf/include/CFL/CFLVF.h

@@ -46,6 +46,9 @@ public:
     {
     }
 
+    /// Parameter Checking
+    virtual void checkParameter();
+
     /// Initialize the grammar, graph, solver
     virtual void initialize();
 

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

@@ -266,6 +266,7 @@ public:
     static const Option<bool>  CFLSVFG;
     static const Option<bool> POCRAlias;
     static const Option<bool> POCRHybrid;
+    static const Option<bool> Customized;
 
     // Loop Analysis
     static const Option<bool> LoopAnalysis;

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

@@ -215,17 +215,24 @@ inline CallSite getSVFCallSite(const SVFValue* value)
 }
 
 /// Split into two substrings around the first occurrence of a separator string.
-inline std::vector<std::string> split(const std::string& s, char seperator)
+inline std::vector<std::string> split(const std::string& s, char separator)
 {
     std::vector<std::string> output;
     std::string::size_type prev_pos = 0, pos = 0;
-    while((pos = s.find(seperator, pos)) != std::string::npos)
+    while ((pos = s.find(separator, pos)) != std::string::npos)
     {
-        std::string substring( s.substr(prev_pos, pos-prev_pos) );
-        output.push_back(substring);
+        std::string substring(s.substr(prev_pos, pos - prev_pos));
+        if (!substring.empty())
+        {
+            output.push_back(substring);
+        }
         prev_pos = ++pos;
     }
-    output.push_back(s.substr(prev_pos, pos-prev_pos));
+    std::string lastSubstring(s.substr(prev_pos, pos - prev_pos));
+    if (!lastSubstring.empty())
+    {
+        output.push_back(lastSubstring);
+    }
     return output;
 }
 

package/package.json

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