svf-tools 1.0.729 → 1.0.731

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-llvm/include/SVF-LLVM/LLVMModule.h

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

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

@@ -409,6 +409,29 @@ void viewCFG(const Function* fun);
 // Dump Control Flow Graph of llvm function, without instructions
 void viewCFGOnly(const Function* fun);
 
+/*
+ * Get the vtable struct of a class.
+ *
+ * Given the class:
+ *
+ *   class A {
+ *     virtual ~A();
+ *   };
+ *   A::~A() = default;
+ *
+ *  The corresponding vtable @_ZTV1A is of type:
+ *
+ *    { [4 x i8*] }
+ *
+ *  If the program has been compiled with AddressSanitizer,
+ *  the vtable will have redzones and appear as:
+ *
+ *    { { [4 x i8*] }, [32 x i8] }
+ *
+ *  See https://github.com/SVF-tools/SVF/issues/1114 for more.
+ */
+const ConstantStruct *getVtblStruct(const GlobalValue *vtbl);
+
 bool isValVtbl(const Value* val);
 bool isLoadVtblInst(const LoadInst* loadInst);
 bool isVirtualCallSite(const CallBase* cs);

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/CHGBuilder.cpp

@@ -90,8 +90,7 @@ void CHGBuilder::buildCHGNodes(const GlobalValue *globalvalue)
 {
     if (LLVMUtil::isValVtbl(globalvalue) && globalvalue->getNumOperands() > 0)
     {
-        const ConstantStruct *vtblStruct = SVFUtil::dyn_cast<ConstantStruct>(globalvalue->getOperand(0));
-        assert(vtblStruct && "Initializer of a vtable not a struct?");
+        const ConstantStruct *vtblStruct = LLVMUtil::getVtblStruct(globalvalue);
         string className = getClassNameFromVtblObj(globalvalue->getName().str());
         if (!chg->getNode(className))
             createNode(className);
@@ -367,9 +366,7 @@ void CHGBuilder::analyzeVTables(const Module &M)
         const GlobalValue *globalvalue = SVFUtil::dyn_cast<const GlobalValue>(&(*I));
         if (LLVMUtil::isValVtbl(globalvalue) && globalvalue->getNumOperands() > 0)
         {
-            const ConstantStruct *vtblStruct =
-                SVFUtil::dyn_cast<ConstantStruct>(globalvalue->getOperand(0));
-            assert(vtblStruct && "Initializer of a vtable not a struct?");
+            const ConstantStruct *vtblStruct = LLVMUtil::getVtblStruct(globalvalue);
 
             string vtblClassName = getClassNameFromVtblObj(globalvalue->getName().str());
             CHNode *node = chg->getNode(vtblClassName);

package/svf-llvm/lib/DCHG.cpp

@@ -180,8 +180,7 @@ void DCHGraph::buildVTables(const SVFModule &module)
                 node->setVTable(svfgv);
                 vtblToTypeMap[svfgv] = getCanonicalType(type);
 
-                const ConstantStruct *vtbls = SVFUtil::dyn_cast<ConstantStruct>(gv->getOperand(0));
-                assert(vtbls && "unexpected vtable type");
+                const ConstantStruct *vtbls = LLVMUtil::getVtblStruct(gv);
                 for (unsigned nthVtbl = 0; nthVtbl < vtbls->getNumOperands(); ++nthVtbl)
                 {
                     const ConstantArray *vtbl = SVFUtil::dyn_cast<ConstantArray>(vtbls->getOperand(nthVtbl));

package/svf-llvm/lib/LLVMUtil.cpp

@@ -682,6 +682,19 @@ bool LLVMUtil::isConstantObjSym(const Value* val)
     return LLVMUtil::isConstDataOrAggData(val);
 }
 
+const ConstantStruct *LLVMUtil::getVtblStruct(const GlobalValue *vtbl)
+{
+    const ConstantStruct *vtblStruct = SVFUtil::dyn_cast<ConstantStruct>(vtbl->getOperand(0));
+    assert(vtblStruct && "Initializer of a vtable not a struct?");
+
+    if (vtblStruct->getNumOperands() == 2 &&
+            SVFUtil::isa<ConstantStruct>(vtblStruct->getOperand(0)) &&
+            vtblStruct->getOperand(1)->getType()->isArrayTy())
+        return SVFUtil::cast<ConstantStruct>(vtblStruct->getOperand(0));
+
+    return vtblStruct;
+}
+
 bool LLVMUtil::isValVtbl(const Value* val)
 {
     if (!SVFUtil::isa<GlobalVariable>(val))
@@ -1036,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))
-    {
-        rawstr << "Function: " << fun->getName() << " ";
-    }
-    else if (const SVFBasicBlock* bb = SVFUtil::dyn_cast<SVFBasicBlock>(svfValue))
+    if (LLVMModuleSet::getLLVMModuleSet()->getLLVMValue(svfValue) == nullptr)
     {
-        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)