svf-tools 1.0.549 → 1.0.550

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -1125,20 +1125,43 @@ void SVFIRBuilder::addComplexConsForExt(Value *D, Value *S, const Value* szValue
     }
 }
 
-/*!
- * Get NodeId of s
- */
-NodeID SVFIRBuilder::parseNode(std::string s, CallSite cs, const Instruction *inst)
+void SVFIRBuilder::parseOperations(std::vector<ExtAPI::Operation>  &operations, CallSite cs)
 {
-    int nodeIDType = ExtAPI::getExtAPI()->getNodeIDType(s);
-    if (nodeIDType >=0)
-        return getValueNode(cs.getArgument(nodeIDType));
-    if (nodeIDType == -1)
-        return getValueNode(inst);
-    if (nodeIDType == -2)
-        return pag->addDummyValNode();
-    assert(false && "The operand format of function operation is illegal!");
-    return -1;
+    // Record all dummy nodes
+    std::map<std::string, NodeID> nodeIDMap;
+    for (ExtAPI::Operation& operation : operations)
+    {
+        std::string op = operation.getOperator();
+        std::vector<NodeID> operands;
+        if (op == "funptr_ops" || op == "Rb_tree_ops")
+            continue;
+        for (auto s: operation.getOperandStr())
+        {
+            NodeID operandID;
+            // There is already a NodeID in nodeIDMap
+            if (nodeIDMap.find(s) != nodeIDMap.end())
+                operandID = nodeIDMap[s];
+            else
+            {
+                int nodeIDType = ExtAPI::getExtAPI()->getNodeIDType(s);
+                if (nodeIDType >= 0)
+                    operandID = getValueNode(cs.getArgument(nodeIDType));
+                else if (nodeIDType == -1)
+                    operandID = getValueNode(cs.getInstruction());
+                else if (nodeIDType == -2)
+                    operandID = pag->addDummyValNode();
+                else if (nodeIDType == -3)
+                    operandID = getObjectNode(cs.getInstruction());
+                else if (nodeIDType == -4)
+                    operandID = atoi(s.c_str());
+                else
+                    assert(false && "The operand format of function operation is illegal!");
+                nodeIDMap.insert(std::pair<std::string, NodeID>(s, operandID));
+            }
+            operands.push_back(operandID);
+        }
+        operation.setOperands(operands);
+    }
 }
 
 /*!
@@ -1184,7 +1207,7 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
         if (isExtCall(callee))
         {
             std::string funName = ExtAPI::getExtAPI()->get_name(callee);
-            std::vector<std::vector<ExtAPI::Operation *>> allOperations = ExtAPI::getExtAPI()->getAllOperations(funName);
+            std::vector<ExtAPI::Operation>  allOperations = ExtAPI::getExtAPI()->getAllOperations(funName);
             if (allOperations.size() == 0)
             {
                 std::string str;
@@ -1194,233 +1217,110 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
             }
             else
             {
-                for (auto operations: allOperations)
+                parseOperations(allOperations, cs);
+                for (auto op : allOperations)
                 {
-                    NodeID tempNode = -1;
-                    // Record the previous operation
-                    ExtAPI::Operation *preOp = nullptr;
-                    for (auto op : operations)
+                    if (op.getOperator() == "AddrStmt")
                     {
-                        ExtAPI::extf_t opName = ExtAPI::getExtAPI()->get_opName(op->getOperation());
-                        std::vector<std::string> args = op->getArgs();
-
-                        switch (opName)
-                        {
-                        case ExtAPI::EXT_ADDR:
-                        {
-                            if (args.size() == 1)
-                            {
-                                if (!SVFUtil::isa<PointerType>(inst->getType()))
-                                    break;
-                                // e.g. void *realloc(void *ptr, size_t size)
-                                // if ptr is null then we will treat it as a malloc
-                                // if ptr is not null, then we assume a new data memory will be attached to
-                                // the tail of old allocated memory block.
-                                if (SVFUtil::isa<ConstantPointerNull>(cs.getArgument(0)))
-                                {
-                                    NodeID val = parseNode(args[0], cs, inst);
-                                    NodeID obj = getObjectNode(inst);
-                                    if (val && obj)
-                                        addAddrEdge(obj, val);
-                                }
-                            }
-                            break;
-                        }
-                        case ExtAPI::EXT_COPY:
-                        {
-                            if(operations.size() == 1)
-                            {
-                                NodeID vnS = parseNode(args[0], cs, inst);
-                                NodeID vnD = parseNode(args[1], cs, inst);
-                                if (vnS && vnD)
-                                    addCopyEdge(vnS, vnD);
-                            }
-                            break;
-                        }
-                        case ExtAPI::EXT_LOAD:
-                        {
-                            NodeID vnS = parseNode(args[0], cs, inst);
-                            NodeID vnD = parseNode(args[1], cs, inst);
-                            if (vnS && vnD)
-                            {
-                                addLoadEdge(vnS, vnD);
-                                if (operations.size() > 1 && !preOp)
-                                {
-                                    preOp = op;
-                                    tempNode = vnD;
-                                }
-                            }
-                            break;
-                        }
-                        case ExtAPI::EXT_STORE:
-                        {
-                            if (operations.size() == 1)
-                            {
-                                NodeID vnS = parseNode(args[0], cs, inst);
-                                NodeID vnD = parseNode(args[1], cs, inst);
-                                if (vnS && vnD)
-                                    addStoreEdge(vnS, vnD);
-                            }
-                            else
-                            {
-                                if(preOp && preOp->getArgs()[1] == op->getArgs()[0])
-                                {
-                                    NodeID vnD = parseNode(args[1], cs, inst);
-                                    addStoreEdge(tempNode, vnD);
-                                }
-                            }
-                            break;
-                        }
-                        case ExtAPI::EXT_GEP:
-                        {
-                            // "compound"
-                            if(operations.size() > 1)
-                            {
-                                // multiple GEP operations
-                                if (!preOp)
-                                {
-                                    NodeID vnS = parseNode(args[0], cs, inst);
-                                    NodeID vnD = parseNode(args[1], cs, inst);
-                                    u32_t offset = stoul(args[2]);
-                                    if (vnD && vnS)
-                                    {
-                                        LocationSet ls(offset);
-                                        addNormalGepEdge(vnS, vnD, ls);
-                                        tempNode = vnD;
-                                    }
-                                }
-                                else
-                                {
-                                    if(op->getArgs()[0] == preOp->getArgs()[1])
-                                    {
-                                        NodeID vnD = parseNode(args[1], cs, inst);
-                                        u32_t offset = stoul(args[2]);
-                                        if (vnD)
-                                        {
-                                            LocationSet ls(offset);
-                                            addNormalGepEdge(tempNode, vnD, ls);
-                                        }
-                                    }
-                                }
-
-                                if (operations.back() == op)
-                                    preOp = nullptr;
-                                preOp = op;
-                            }
-                            // General GEP operation
-                            else
-                            {
-                                NodeID vnS = parseNode(args[0], cs, inst);
-                                NodeID vnD = parseNode(args[1], cs, inst);
-                                u32_t offset = stoul(args[2]);
-                                if (vnD && vnS)
-                                {
-                                    LocationSet ls(offset);
-                                    addNormalGepEdge(vnS, vnD, ls);
-                                }
-                            }
-                            break;
-                        }
-                        case ExtAPI::EXT_COPY_N:
-                        {
-                            // void *memset(void *str, int c, size_t n)
-                            // this is for memset(void *str, int c, size_t n)
-                            // which copies the character c (an unsigned char) to the first n characters of the string pointed to, by the argument str
-                            u32_t arg_posA = ExtAPI::getExtAPI()->getArgPos(args[0]);
-                            u32_t arg_posB = ExtAPI::getExtAPI()->getArgPos(args[1]);
-                            u32_t arg_posC = ExtAPI::getExtAPI()->getArgPos(args[2]);
-                            std::vector<LocationSet> dstFields;
-                            const Type *dtype = getBaseTypeAndFlattenedFields(cs.getArgument(arg_posA), dstFields, cs.getArgument(arg_posC));
-                            u32_t sz = dstFields.size();
-                            // For each field (i), add store edge *(arg0 + i) = arg1
-                            for (u32_t index = 0; index < sz; index++)
-                            {
-                                const Type *dElementType = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(dtype, dstFields[index].accumulateConstantFieldIdx());
-                                NodeID dField = getGepValVar(cs.getArgument(arg_posA), dstFields[index], dElementType);
-                                addStoreEdge(pag->getValueNode(cs.getArgument(arg_posB)), dField);
-                            }
-                            if (SVFUtil::isa<PointerType>(inst->getType()))
-                                addCopyEdge(getValueNode(cs.getArgument(arg_posA)), getValueNode(inst));
-                            break;
-                        }
-                        case ExtAPI::EXT_COPY_MN:
+                        addAddrEdge(op.getOperands()[0], op.getOperands()[1]);
+                    }
+                    else if (op.getOperator() == "CopyStmt")
+                    {
+                        addCopyEdge(op.getOperands()[0], op.getOperands()[1]);
+                    }
+                    else if (op.getOperator() == "LoadStmt")
+                    {
+                        addLoadEdge(op.getOperands()[0], op.getOperands()[1]);
+                    }
+                    else if (op.getOperator() == "StoreStmt")
+                    {
+                        addStoreEdge(op.getOperands()[0], op.getOperands()[1]);
+                    }
+                    else if (op.getOperator() == "GepStmt")
+                    {
+                        LocationSet ls(op.getOperands()[2]);
+                        addNormalGepEdge(op.getOperands()[0], op.getOperands()[1], ls);
+                    }
+                    else if (op.getOperator() == "memset_like")
+                    {
+                        // this is for memset(void *str, int c, size_t n)
+                        // which copies the character c (an unsigned char) to the first n characters of the string pointed to, by the argument str
+                        std::vector<LocationSet> dstFields;
+                        const Type *dtype = getBaseTypeAndFlattenedFields(cs.getArgument(0), dstFields, cs.getArgument(2));
+                        u32_t sz = dstFields.size();
+                        //For each field (i), add store edge *(arg0 + i) = arg1
+                        for (u32_t index = 0; index < sz; index++)
                         {
-                            u32_t arg_posA = ExtAPI::getExtAPI()->getArgPos(args[0]);
-                            u32_t arg_posB = ExtAPI::getExtAPI()->getArgPos(args[1]);
-                            if (args.size() >= 3)
-                            {
-                                u32_t arg_posC = ExtAPI::getExtAPI()->getArgPos(args[2]);
-                                addComplexConsForExt(cs.getArgument(arg_posA), cs.getArgument(arg_posB), cs.getArgument(arg_posC));
-                            }
-                            else
-                                addComplexConsForExt(cs.getArgument(arg_posA), cs.getArgument(arg_posB), nullptr);
-                            break;
+                            const Type* dElementType = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(dtype, dstFields[index].accumulateConstantFieldIdx());
+                            NodeID dField = getGepValVar(cs.getArgument(0), dstFields[index], dElementType);
+                            addStoreEdge(pag->getValueNode(cs.getArgument(1)),dField);
                         }
-                        case ExtAPI::EXT_FUNPTR:
+                        if(SVFUtil::isa<PointerType>(inst->getType()))
+                            addCopyEdge(getValueNode(cs.getArgument(0)), getValueNode(inst));
+                    }
+                    else if (op.getOperator() == "memcpy_like")
+                    {
+                        /// handle strcpy
+                        if(cs.arg_size()>=3)
+                            addComplexConsForExt(cs.getArgument(op.getOperands()[0]), cs.getArgument(op.getOperands()[1]), cs.getArgument(op.getOperands()[2]));
+                        else
+                            addComplexConsForExt(cs.getArgument(op.getOperands()[0]), cs.getArgument(op.getOperands()[1]), nullptr);
+                    }
+                    else if (op.getOperator() == "funptr_ops")
+                    {
+                        /// handling external function e.g., void *dlsym(void *handle, const char *funname);
+                        const Value *src = cs.getArgument(1);
+                        if(const GetElementPtrInst* gep = SVFUtil::dyn_cast<GetElementPtrInst>(src))
+                            src = stripConstantCasts(gep->getPointerOperand());
+                        if(const GlobalVariable* glob = SVFUtil::dyn_cast<GlobalVariable>(src))
                         {
-                            /// handling external function e.g., void *dlsym(void *handle, const char *funname);
-                            u32_t arg_posA = ExtAPI::getExtAPI()->getArgPos(args[0]);
-                            const Value *src = cs.getArgument(arg_posA);
-                            if (const GetElementPtrInst *gep = SVFUtil::dyn_cast<GetElementPtrInst>(src))
-                                src = stripConstantCasts(gep->getPointerOperand());
-                            if (const GlobalVariable *glob = SVFUtil::dyn_cast<GlobalVariable>(src))
+                            if(const ConstantDataArray* constarray = SVFUtil::dyn_cast<ConstantDataArray>(glob->getInitializer()))
                             {
-                                if (const ConstantDataArray *constarray = SVFUtil::dyn_cast<ConstantDataArray>(glob->getInitializer()))
+                                if(const SVFFunction* fun = getProgFunction(svfMod,constarray->getAsCString().str()))
                                 {
-                                    if (const SVFFunction *fun = getProgFunction(svfMod, constarray->getAsCString().str()))
-                                    {
-                                        NodeID srcNode = getValueNode(fun->getLLVMFun());
-                                        addCopyEdge(srcNode, getValueNode(inst));
-                                    }
+                                    NodeID srcNode = getValueNode(fun->getLLVMFun());
+                                    addCopyEdge(srcNode,  getValueNode(inst));
                                 }
                             }
-                            break;
                         }
-                        case ExtAPI::EXT_COMPLEX:
-                        {
-                            assert(cs.arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
+                    }
+                    else if (op.getOperator() == "Rb_tree_ops")
+                    {
+                        assert(cs.arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
 
-                            Value *argA = cs.getArgument(ExtAPI::getExtAPI()->getArgPos(args[0]));
-                            Value *argB = cs.getArgument(ExtAPI::getExtAPI()->getArgPos(args[1]));
+                        Value *vArg1 = cs.getArgument(1);
+                        Value *vArg3 = cs.getArgument(3);
 
-                            // We have vArg3 points to the entry of _Rb_tree_node_base { color; parent; left; right; }.
-                            // Now we calculate the offset from base to vArg3
-                            NodeID vnB = pag->getValueNode(argB);
-                            s32_t offset = getLocationSetFromBaseNode(vnB).accumulateConstantFieldIdx();
+                        // We have vArg3 points to the entry of _Rb_tree_node_base { color; parent; left; right; }.
+                        // Now we calculate the offset from base to vArg3
+                        NodeID vnArg3 = pag->getValueNode(vArg3);
+                        s32_t offset = getLocationSetFromBaseNode(vnArg3).accumulateConstantFieldIdx();
 
-                            // We get all flattened fields of base
-                            vector<LocationSet> fields;
-                            const Type *type = getBaseTypeAndFlattenedFields(argB, fields, nullptr);
+                        // We get all flattened fields of base
+                        vector<LocationSet> fields;
+                        const Type *type = getBaseTypeAndFlattenedFields(vArg3, fields, nullptr);
 
-                            // We summarize the side effects: arg3->parent = arg1, arg3->left = arg1, arg3->right = arg1
-                            // Note that arg0 is aligned with "offset".
-                            for (s32_t i = offset + 1; i <= offset + 3; ++i)
-                            {
-                                if ((u32_t)i >= fields.size())
-                                    break;
-                                const Type *elementType = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, fields[i].accumulateConstantFieldIdx());
-                                NodeID vnD = getGepValVar(argB, fields[i], elementType);
-                                NodeID vnS = getValueNode(argA);
-                                if (vnD && vnS)
-                                    addStoreEdge(vnS, vnD);
-                            }
-                            break;
-                        }
-                        // default
-                        // illegal function operation of external function
-                        case ExtAPI::EXT_OTHER:
-                        default:
+                        // We summarize the side effects: arg3->parent = arg1, arg3->left = arg1, arg3->right = arg1
+                        // Note that arg0 is aligned with "offset".
+                        for (s32_t i = offset + 1; i <= offset + 3; ++i)
                         {
-                            assert(false && "new type of SVFStmt for external calls?");
-                        }
+                            if((u32_t)i >= fields.size())
+                                break;
+                            const Type* elementType = SymbolTableInfo::SymbolInfo()->getFlatternedElemType(type, fields[i].accumulateConstantFieldIdx());
+                            NodeID vnD = getGepValVar(vArg3, fields[i], elementType);
+                            NodeID vnS = getValueNode(vArg1);
+                            if(vnD && vnS)
+                                addStoreEdge(vnS,vnD);
                         }
                     }
-                    for(u32_t it = 0; it != operations.size(); ++it)
-                        delete operations[it];
-                    operations.clear();
+                    // default
+                    // illegal function operation of external function
+                    else
+                    {
+                        assert(false && "new type of SVFStmt for external calls?");
+                    }
                 }
             }
-            allOperations.clear();
         }
 
         /// create inter-procedural SVFIR edges for thread forks

package/lib/Util/ExtAPI.cpp

@@ -201,17 +201,12 @@ void ExtAPI::add_entry(const char* funName, extType type, bool overwrite_app_fun
 }
 
 // Get the corresponding name in ext_t, e.g. "EXT_ADDR" in {"addr", EXT_ADDR},
-ExtAPI::extf_t ExtAPI::get_opName(const std::string& s)
+std::string ExtAPI::get_opName(const std::string& s)
 {
-    std::map<std::string, extf_t>::iterator pos = op_pair.find(s);
-    if (pos != op_pair.end())
-    {
-        return pos->second;
-    }
-    else
-    {
-        return EXT_OTHER;
-    }
+    u32_t end = 0;
+    while(end < s.size() && !isdigit(s[end]))
+        end++;
+    return s.substr(0, end);
 }
 
 const std::string& ExtAPI::extType_toString(extType type)
@@ -227,13 +222,15 @@ const std::string& ExtAPI::extType_toString(extType type)
 // Get numeric index of the argument in external function
 u32_t ExtAPI::getArgPos(std::string s)
 {
-    if(s[0] != 'A')
-        assert(false && "the argument of extern function in ExtAPI.json should start with 'A' !");
-    u32_t i = 1;
-    u32_t start = i;
-    while(i < s.size() && isdigit(s[i]))
-        i++;
-    std::string digitStr = s.substr(start, i-start);
+    u32_t start = 0;
+    while (start < s.size() && isalpha(s[start]))
+        start++;
+    if (s.substr(0, start) != "Arg")
+        assert(false && "the argument of extern function in ExtAPI.json should start with 'Arg' !");
+    u32_t end = start + 1;
+    while (end < s.size() && isdigit(s[end]))
+        end++;
+    std::string digitStr = s.substr(start, end - start);
     u32_t argNum = atoi(digitStr.c_str());
     return argNum;
 }
@@ -241,29 +238,43 @@ u32_t ExtAPI::getArgPos(std::string s)
 // return value >= 0 is an argument node
 // return value = -1 is an inst node
 // return value = -2 is a Dummy node
-// return value = -2 is an illegal operand format
+// return value = -3 is an object node
+// return value = -4 is an offset
+// return value = -5 is an illegal operand format
 int ExtAPI::getNodeIDType(std::string s)
 {
-    size_t argPos = -1;
+    u32_t argPos = -1;
     // 'A' represents an argument
     if (s.size() == 0)
-        return -3;
-    if (s[0] == 'A')
+        return -5;
+    u32_t start = 0;
+    while (start < s.size() && isalpha(s[start]))
+        start++;
+    std::string argStr = s.substr(0, start);
+    if (argStr == "Arg")
     {
-        size_t start = 1;
-        size_t end = 1;
+        u32_t end = start + 1;
         while(end < s.size() && isdigit(s[end]))
             end++;
         std::string digitStr = s.substr(start, end - start);
         argPos = atoi(digitStr.c_str());
         return argPos;
     }
-    if(s[0] == 'L')
+    else if(argStr == "Ret")
         return -1;
-    if(s[0] == 'D')
+    else if(argStr == "Dummy")
         return -2;
+    else if(argStr == "Obj")
+        return -3;
+    else // offset
+    {
+        u32_t i=0;
+        while(i < s.size() && isdigit(s[i])) i++;
+        if (i == s.size())
+            return -4;
+    }
 
-    return -3;
+    return -5;
 }
 
 // Get external function name, e.g "memcpy"
@@ -288,9 +299,9 @@ cJSON *ExtAPI::get_FunJson(const std::string &funName)
 }
 
 // Get all operations of an extern function
-std::vector<std::vector<ExtAPI::Operation *>> ExtAPI::getAllOperations(std::string funName)
+std::vector<ExtAPI::Operation> ExtAPI::getAllOperations(std::string funName)
 {
-    std::vector<std::vector<ExtAPI::Operation *>> allOperations;
+    std::vector<ExtAPI::Operation> allOperations;
     cJSON *item = get_FunJson(funName);
     if (item != nullptr)
     {
@@ -300,52 +311,25 @@ std::vector<std::vector<ExtAPI::Operation *>> ExtAPI::getAllOperations(std::stri
         std::vector<ExtAPI::Operation *> operations;
         while (obj)
         {
-            std::string operationName;
-            std::vector<std::string> arguments;
-            Operation operation;
-            // All operations in "compound" are related to each other.
-            // For example, the first parameter of the second operation
-            // depends on the second parameter of the first operation.
-            // Therefore, all operations in "compound" need to be processed uniformly
-            if (strstr(obj->string, "compound") != NULL)
+            std::string op;
+            std::vector<std::string> operandsStr;
+            std::map<std::string, NodeID> opMap;
+            if (obj->type == cJSON_Object || obj->type == cJSON_Array)
             {
-                if (obj->type == cJSON_Object)
+                op = get_opName(obj -> string);
+                cJSON *value = obj->child;
+                std::vector<std::string> args;
+                while (value)
                 {
-                    cJSON *value = obj->child;
-                    while (value)
+                    if (value->type == cJSON_String)
                     {
-                        operationName = value -> string;
-                        if (value->type == cJSON_Object)
-                        {
-                            cJSON *edge = value->child;
-                            arguments = ExtAPI::getExtAPI()->get_opArgs(edge);
-                        }
-                        else
-                        {
-                            if (value->type == cJSON_String)
-                                arguments.push_back(value->valuestring);
-                            else
-                                assert(false && "The function operation format is illegal!");
-                        }
-                        operations.push_back(new ExtAPI::Operation(operationName, arguments));
-                        arguments.clear();
-                        value = value->next;
+                        operandsStr.push_back(value->valuestring);
                     }
+                    value = value->next;
                 }
             }
-            // General operation(Independent operation, the operation does not need to dependent other operations' arguments)
-            else
-            {
-                if (obj->type == cJSON_Object || obj->type == cJSON_Array)
-                {
-                    operationName = obj -> string;
-                    cJSON *edge = obj->child;
-                    arguments = ExtAPI::getExtAPI()->get_opArgs(edge);
-                    operations.push_back(new ExtAPI::Operation(operationName, arguments));
-                    arguments.clear();
-                }
-            }
-            allOperations.push_back(operations);
+            ExtAPI::Operation operation(op, operandsStr);
+            allOperations.push_back(operation);
             operations.clear();
 
             obj = obj -> next;
@@ -519,3 +503,4 @@ bool ExtAPI::is_ext(const SVFFunction *F)
     }
     return res;
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svf-tools",
-  "version": "1.0.549",
+  "version": "1.0.550",
   "description": "* <b>[TypeClone](https://github.com/SVF-tools/SVF/wiki/TypeClone) published in our [ECOOP paper](https://yuleisui.github.io/publications/ecoop20.pdf) is now available in SVF </b> * <b>SVF now uses a single script for its build. Just type [`source ./build.sh`](https://github.com/SVF-tools/SVF/blob/master/build.sh) in your terminal, that's it!</b> * <b>SVF now supports LLVM-10.0.0! </b> * <b>We thank [bsauce](https://github.com/bsauce) for writing a user manual of SVF ([link1](https://www.jianshu.com/p/068a08ec749c) and [link2](https://www.jianshu.com/p/777c30d4240e)) in Chinese </b> * <b>SVF now supports LLVM-9.0.0 (Thank [Byoungyoung Lee](https://github.com/SVF-tools/SVF/issues/142) for his help!). </b> * <b>SVF now supports a set of [field-sensitive pointer analyses](https://yuleisui.github.io/publications/sas2019a.pdf). </b> * <b>[Use SVF as an external lib](https://github.com/SVF-tools/SVF/wiki/Using-SVF-as-a-lib-in-your-own-tool) for your own project (Contributed by [Hongxu Chen](https://github.com/HongxuChen)). </b> * <b>SVF now supports LLVM-7.0.0. </b> * <b>SVF now supports Docker. [Try SVF in Docker](https://github.com/SVF-tools/SVF/wiki/Try-SVF-in-Docker)! </b> * <b>SVF now supports [LLVM-6.0.0](https://github.com/svf-tools/SVF/pull/38) (Contributed by [Jack Anthony](https://github.com/jackanth)). </b> * <b>SVF now supports [LLVM-4.0.0](https://github.com/svf-tools/SVF/pull/23) (Contributed by Jared Carlson. Thank [Jared](https://github.com/jcarlson23) and [Will](https://github.com/dtzWill) for their in-depth [discussions](https://github.com/svf-tools/SVF/pull/18) about updating SVF!) </b> * <b>SVF now supports analysis for C++ programs.</b> <br />",
   "main": "index.js",
   "scripts": {