svf-tools 1.0.730 → 1.0.732

package/svf/lib/Util/ExtAPI.cpp

@@ -348,44 +348,116 @@ cJSON* ExtAPI::get_FunJson(const std::string& funName)
     return cJSON_GetObjectItemCaseSensitive(root, funName.c_str());
 }
 
+ExtAPI::Operand ExtAPI::getBasicOperation(cJSON* obj)
+{
+    Operand basicOp;
+    if (strstr(obj->string, "AddrStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Addr);
+    else if (strstr(obj->string, "CopyStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Copy);
+    else if (strstr(obj->string, "LoadStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Load);
+    else if (strstr(obj->string, "StoreStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Store);
+    else if (strstr(obj->string, "GepStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Gep);
+    else if (strstr(obj->string, "ReturnStmt") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Return);
+    else if (strstr(obj->string, "Rb_tree_ops") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Rb_tree_ops);
+    else if (strstr(obj->string, "memcpy_like") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Memcpy_like);
+    else if (strstr(obj->string, "memset_like") != NULL)
+        basicOp.setType(ExtAPI::OperationType::Memset_like);
+    else
+        assert(false && "Unknown operation type");
+
+    cJSON* value = obj->child;
+    while (value)
+    {
+        if (strcmp(value->string, "src") == 0)
+            basicOp.setSrcValue(value->valuestring);
+        else if (strcmp(value->string, "dst") == 0)
+            basicOp.setDstValue(value->valuestring);
+        else if (strcmp(value->string, "offset") == 0 || strcmp(value->string, "size") == 0)
+            basicOp.setOffsetOrSizeStr(value->valuestring);
+        else
+            assert(false && "Unknown operation value");
+        value = value->next;
+    }
+    return basicOp;
+}
+
 // Get all operations of an extern function
-std::vector<ExtAPI::Operation> ExtAPI::getAllOperations(std::string funName)
+ExtAPI::ExtFunctionOps ExtAPI::getExtFunctionOps(std::string funName)
 {
-    std::vector<ExtAPI::Operation> allOperations;
+    auto it = extFunToOps.find(funName);
+    if (it != extFunToOps.end())
+        return it->second;
+
+    ExtAPI::ExtFunctionOps extFunctionOps;
+    extFunctionOps.setExtFunName(funName);
     cJSON* item = get_FunJson(funName);
     if (item != nullptr)
     {
         cJSON* obj = item->child;
         //  Get the first operation of the function
         obj = obj->next->next->next->next;
-        std::vector<ExtAPI::Operation*> operations;
         while (obj)
         {
-            std::string op;
-            std::vector<std::string> operandsStr;
-            std::map<std::string, NodeID> opMap;
+            ExtOperation operation;
             if (obj->type == cJSON_Object || obj->type == cJSON_Array)
             {
-                op = get_opName(obj->string);
-                cJSON* value = obj->child;
-                std::vector<std::string> args;
-                while (value)
+                if (strstr(obj->string, "CallStmt") != NULL)
                 {
-                    if (value->type == cJSON_String)
+                    extFunctionOps.setCallStmtNum(extFunctionOps.getCallStmtNum() + 1);
+                    operation.setCallOp(true);
+                    cJSON* value = obj->child;
+                    while (value)
                     {
-                        operandsStr.push_back(value->valuestring);
+                        if (strcmp(value->string, "callee_name") == 0)
+                            operation.setCalleeName(value->valuestring);
+                        else if (strcmp(value->string, "callee_return") == 0)
+                            operation.setCalleeReturn(value->valuestring);
+                        else if (strcmp(value->string, "callee_arguments") == 0)
+                            operation.setCalleeArguments(value->valuestring);
+                        else
+                            operation.getCalleeOperands().push_back(getBasicOperation(value));
+                        value = value->next;
                     }
-                    value = value->next;
                 }
+                else if (strstr(obj->string, "CondStmt") != NULL)
+                {
+                    operation.setConOp(true);
+                    obj = obj->child;
+                    assert(strcmp(obj->string, "Condition") == 0 && "Unknown operation type");
+                    operation.setConOp(obj->valuestring);
+                    obj = obj->next;
+                    assert(strcmp(obj->string, "TrueBranch") == 0 && "Unknown operation type");
+                    cJSON* value = obj->child;
+                    while (value)
+                    {
+                        operation.getTrueBranchOperands().push_back(getBasicOperation(value));
+                        value = value->next;
+                    }
+                    obj = obj->next;
+                    assert(strcmp(obj->string, "FalseBranch") == 0&& "Unknown operation type");
+                    value = obj->child;
+                    while (value)
+                    {
+                        operation.getFalseBranchOperands().push_back(getBasicOperation(value));
+                        value = value->next;
+                    }
+                }
+                else
+                    operation.setBasicOp(getBasicOperation(obj));
             }
-            ExtAPI::Operation operation(op, operandsStr);
-            allOperations.push_back(operation);
-            operations.clear();
-
             obj = obj->next;
+            extFunctionOps.getOperations().push_back(operation);
         }
     }
-    return allOperations;
+    extFunToOps[funName] = extFunctionOps;
+    return extFunctionOps;
 }
 
 // Get arguments of the operation, e.g. ["A1R", "A0", "A2"]

package/svf/lib/Util/Options.cpp

@@ -869,6 +869,12 @@ const Option<bool> Options::POCRHybrid(
     false
 );
 
+const Option<bool> Options::Customized(
+    "customized",
+    "When explicit to true, user can use any grammar file.",
+    false
+);
+
 const Option<bool> Options::LoopAnalysis(
     "loop-analysis",
     "Analyze every func and get loop info and loop bounds.",

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

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

package/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-llvm/lib/LLVMUtil.cpp

@@ -1049,22 +1049,32 @@ std::string dumpLLVMValue(const SVFValue* svfValue)
 {
     std::string str;
     llvm::raw_string_ostream rawstr(str);
-    if (const SVF::SVFFunction* fun = SVFUtil::dyn_cast<SVFFunction>(svfValue))
+    if (LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(svfValue) == nullptr)
     {
-        rawstr << "Function: " << fun->getName() << " ";
-    }
-    else if (const SVFBasicBlock* bb = SVFUtil::dyn_cast<SVFBasicBlock>(svfValue))
-    {
-        rawstr << "BasicBlock: " << bb->getName() << " ";
+        assert((SVFUtil::isa<SVFInstruction>(svfValue) ||
+                SVFUtil::isa<SVFBasicBlock>(svfValue)) && "Manually created SVF call inst, actual parameter and BasicBlock by ExtAPI do not have LLVM value!");
+        rawstr << svfValue->getName();
+        return rawstr.str();
     }
     else
     {
-        const Value* val =
-            LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(svfValue);
-        rawstr << " " << *val << " ";
+        if (const SVF::SVFFunction* fun = SVFUtil::dyn_cast<SVFFunction>(svfValue))
+        {
+            rawstr << "Function: " << fun->getName() << " ";
+        }
+        else if (const SVFBasicBlock* bb = SVFUtil::dyn_cast<SVFBasicBlock>(svfValue))
+        {
+            rawstr << "BasicBlock: " << bb->getName() << " ";
+        }
+        else
+        {
+            const Value* val =
+                LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(svfValue);
+            rawstr << " " << *val << " ";
+        }
+        rawstr << svfValue->getSourceLoc();
+        return rawstr.str();
     }
-    rawstr << svfValue->getSourceLoc();
-    return rawstr.str();
 }
 
 std::string dumpLLVMType(const SVFType* svfType)