svf-tools 1.0.730 → 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/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)

package/svf-llvm/lib/SVFIRBuilder.cpp

@@ -848,8 +848,7 @@ void SVFIRBuilder::visitCallSite(CallBase* cs)
         {
             // There is no extpag for the function, use the old method.
             preProcessExtCall(cs);
-            SVFInstruction* svfinst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(cs);
-            handleExtCall(svfinst, svfcallee);
+            handleExtCall(svfcall, svfcallee);
         }
         else
         {
@@ -1115,184 +1114,6 @@ const Value* SVFIRBuilder::getBaseValueForExtArg(const Value* V)
     return value;
 }
 
-/*!
- * Find the base type and the max possible offset of an object pointed to by (V).
- */
-const Type* SVFIRBuilder::getBaseTypeAndFlattenedFields(const Value* V, std::vector<LocationSet> &fields, const Value* szValue)
-{
-    assert(V);
-    const Value* value = getBaseValueForExtArg(V);
-    const Type* T = value->getType();
-    while (const PointerType *ptype = SVFUtil::dyn_cast<PointerType>(T))
-        T = getPtrElementType(ptype);
-
-    u32_t numOfElems = pag->getSymbolInfo()->getNumOfFlattenElements(LLVMModuleSet::getLLVMModuleSet()->getSVFType(T));
-    /// use user-specified size for this copy operation if the size is a constaint int
-    if(szValue && SVFUtil::isa<ConstantInt>(szValue))
-    {
-        numOfElems = (numOfElems > SVFUtil::cast<ConstantInt>(szValue)->getSExtValue()) ? SVFUtil::cast<ConstantInt>(szValue)->getSExtValue() : numOfElems;
-    }
-
-    LLVMContext& context = LLVMModuleSet::getLLVMModuleSet()->getContext();
-    for(u32_t ei = 0; ei < numOfElems; ei++)
-    {
-        LocationSet ls(ei);
-        // make a ConstantInt and create char for the content type due to byte-wise copy
-        const ConstantInt* offset = ConstantInt::get(context, llvm::APInt(32, ei));
-        const SVFValue* svfOffset = LLVMModuleSet::getLLVMModuleSet()->getSVFValue(offset);
-        if (!pag->getSymbolInfo()->hasValSym(svfOffset))
-        {
-            SymbolTableBuilder builder(pag->getSymbolInfo());
-            builder.collectSym(offset);
-            pag->addValNode(svfOffset, pag->getSymbolInfo()->getValSym(svfOffset));
-        }
-        ls.addOffsetVarAndGepTypePair(getPAG()->getGNode(getPAG()->getValueNode(svfOffset)), nullptr);
-        fields.push_back(ls);
-    }
-    return T;
-}
-
-/*!
- * Add the load/store constraints and temp. nodes for the complex constraint
- * *D = *S (where D/S may point to structs).
- */
-void SVFIRBuilder::addComplexConsForExt(const SVFValue* D, const SVFValue* S, const SVFValue* szValue)
-{
-    assert(D && S);
-    NodeID vnD= pag->getValueNode(D), vnS= pag->getValueNode(S);
-    if(!vnD || !vnS)
-        return;
-
-    std::vector<LocationSet> fields;
-
-    //Get the max possible size of the copy, unless it was provided.
-    const SVFType* stype = pag->getTypeLocSetsMap(vnS).first;
-    const SVFType* dtype = pag->getTypeLocSetsMap(vnD).first;
-    std::vector<LocationSet> srcFields = pag->getTypeLocSetsMap(vnS).second;
-    std::vector<LocationSet> dstFields = pag->getTypeLocSetsMap(vnD).second;
-
-    if(srcFields.size() > dstFields.size())
-        fields = dstFields;
-    else
-        fields = srcFields;
-
-    /// If sz is 0, we will add edges for all fields.
-    u32_t sz = fields.size();
-    if (szValue && SVFUtil::dyn_cast<SVFConstantInt>(szValue))
-    {
-        const SVFConstantInt* arg2 = SVFUtil::dyn_cast<SVFConstantInt>(szValue);
-        sz = (fields.size() > static_cast<u32_t>(arg2->getSExtValue())) ? arg2->getSExtValue() : fields.size();
-    }
-
-    if (fields.size() == 1 && (SVFUtil::isa<SVFConstantData>(D) || SVFUtil::isa<SVFConstantData>(S)))
-    {
-        NodeID dummy = pag->addDummyValNode();
-        addLoadEdge(vnD,dummy);
-        addStoreEdge(dummy,vnS);
-        return;
-    }
-
-    //For each field (i), add (Ti = *S + i) and (*D + i = Ti).
-    for (u32_t index = 0; index < sz; index++)
-    {
-        const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(dtype,
-                                      fields[index].getConstantFieldIdx());
-        const SVFType* sElementType = pag->getSymbolInfo()->getFlatternedElemType(stype,
-                                      fields[index].getConstantFieldIdx());
-        NodeID dField = getGepValVar(D,fields[index],dElementType);
-        NodeID sField = getGepValVar(S,fields[index],sElementType);
-        NodeID dummy = pag->addDummyValNode();
-        addLoadEdge(sField,dummy);
-        addStoreEdge(dummy,dField);
-    }
-}
-
-void SVFIRBuilder::parseOperations(std::vector<ExtAPI::Operation>  &operations, const SVFCallInst* svfcall)
-{
-    // Record all dummy nodes
-    std::map<std::string, NodeID> nodeIDMap;
-    for (ExtAPI::Operation& operation : operations)
-    {
-        std::vector<NodeID>& operands = operation.getOperands();
-        if (operation.getOperator() == "funptr_ops" || operation.getOperator() == "Rb_tree_ops")
-            continue;
-        for (const std::string& s : operation.getOperandStr())
-        {
-            // There is already a NodeID in nodeIDMap
-            if (nodeIDMap.find(s) != nodeIDMap.end())
-                operands.push_back(nodeIDMap[s]);
-            else
-            {
-                s32_t nodeIDType = ExtAPI::getExtAPI()->getNodeIDType(s);
-                // return value >= 0 is an argument node
-                if (nodeIDType >= 0)
-                {
-                    if( svfcall->arg_size() <= (u32_t) nodeIDType)
-                        assert(false && "Argument out of bounds!");
-                    else if (operation.getOperator() == "memcpy_like" || operation.getOperator() == "memset_like")
-                    {
-                        operands.push_back(nodeIDType);
-                        nodeIDMap[s] = nodeIDType;
-                    }
-                    else
-                    {
-                        operands.push_back(pag->getValueNode(svfcall->getArgOperand(nodeIDType)));
-                        nodeIDMap[s] = pag->getValueNode(svfcall->getArgOperand(nodeIDType));
-                    }
-                }
-                // return value = -1 is an inst node
-                else if (nodeIDType == -1)
-                {
-                    operands.push_back(pag->getValueNode(svfcall));
-                    nodeIDMap[s] = pag->getValueNode(svfcall);
-                }
-                // return value = -2 is a Dummy node
-                else if (nodeIDType == -2)
-                {
-                    operands.push_back(pag->addDummyValNode());
-                    nodeIDMap[s] = operands[operands.size() - 1];
-                }
-                // return value = -3 is an object node
-                else if (nodeIDType == -3)
-                {
-                    if (svfcall->getType()->isPointerTy())
-                    {
-                        NodeID objId;
-                        // Indirect call
-                        if (getCallee(svfcall) == nullptr)
-                            objId = pag->addDummyObjNode(svfcall->getType());
-                        else // Direct call
-                            objId = pag->getObjectNode(svfcall);
-
-                        operands.push_back(objId);
-                        nodeIDMap[s] = objId;
-                    }
-                }
-                // return value = -4 is a nullptr node
-                else if (nodeIDType == -4)
-                {
-                    operands.push_back(pag->getNullPtr());
-                    nodeIDMap[s] = operands[operands.size() - 1];
-                }
-                // return value = -5 is an offset
-                else if (nodeIDType == -5)
-                {
-                    for (char const &c : s)
-                    {
-                        if (std::isdigit(c) == 0)
-                            assert(false && "Invalid offset!");
-                    }
-                    operands.push_back(atoi(s.c_str()));
-                    nodeIDMap[s] = atoi(s.c_str());
-                }
-                // return value = -6 is an illegal operand format
-                else
-                    assert(false && "The operand format of function operation is illegal!");
-            }
-        }
-    }
-}
-
 void SVFIRBuilder::preProcessExtCall(CallBase* cs)
 {
     const SVFInstruction* svfinst = LLVMModuleSet::getLLVMModuleSet()->getSVFInstruction(cs);
@@ -1360,249 +1181,6 @@ void SVFIRBuilder::preProcessExtCall(CallBase* cs)
     }
 }
 
-/*!
- * Handle external calls
- */
-void SVFIRBuilder::handleExtCall(SVFInstruction* svfinst, const SVFFunction* svfcallee)
-{
-    const SVFCallInst* svfcall = SVFUtil::cast<SVFCallInst>(svfinst);
-
-    if (isHeapAllocOrStaticExtCall(svfinst))
-    {
-        // case 1: ret = new obj
-        if (isHeapAllocExtCallViaRet(svfinst) || isStaticExtCall(svfinst))
-        {
-            NodeID val = pag->getValueNode(svfinst);
-            NodeID obj = pag->getObjectNode(svfinst);
-            addAddrEdge(obj, val);
-        }
-        // case 2: *arg = new obj
-        else
-        {
-            assert(isHeapAllocExtCallViaArg(svfinst) && "Must be heap alloc call via arg.");
-            u32_t arg_pos = getHeapAllocHoldingArgPosition(svfcallee);
-            const SVFValue* arg = svfcall->getArgOperand(arg_pos);
-            if (arg->getType()->isPointerTy())
-            {
-                NodeID vnArg = pag->getValueNode(arg);
-                NodeID dummy = pag->addDummyValNode();
-                NodeID obj = pag->addDummyObjNode(arg->getType());
-                if (vnArg && dummy && obj)
-                {
-                    addAddrEdge(obj, dummy);
-                    addStoreEdge(dummy, vnArg);
-                }
-            }
-            else
-            {
-                writeWrnMsg("Arg receiving new object must be pointer type");
-            }
-        }
-    }
-    else
-    {
-        if (isExtCall(svfcallee))
-        {
-            std::string funName = ExtAPI::getExtAPI()->get_name(svfcallee);
-            std::vector<ExtAPI::Operation>  allOperations = ExtAPI::getExtAPI()->getAllOperations(funName);
-            if (allOperations.size() == 0)
-            {
-                std::string str;
-                std::stringstream rawstr(str);
-                rawstr << "function " << funName << " not in the external function summary ExtAPI.json file";
-                writeWrnMsg(rawstr.str());
-            }
-            else
-            {
-                parseOperations(allOperations, svfcall);
-                for (ExtAPI::Operation op : allOperations)
-                {
-                    if (op.getOperator() == "AddrStmt")
-                    {
-                        if (op.getOperands().size() == 2)
-                            addAddrEdge(op.getOperands()[0], op.getOperands()[1]);
-                        else
-                            writeWrnMsg("We need two valid NodeIDs to add an Addr edge");
-                    }
-                    else if (op.getOperator() == "CopyStmt")
-                    {
-                        if (op.getOperands().size() == 2)
-                            addCopyEdge(op.getOperands()[0], op.getOperands()[1]);
-                        else
-                            writeWrnMsg("We need two valid NodeIDs to add a Copy edge");
-                    }
-                    else if (op.getOperator() == "LoadStmt")
-                    {
-                        if (op.getOperands().size() == 2)
-                            addLoadEdge(op.getOperands()[0], op.getOperands()[1]);
-                        else
-                            writeWrnMsg("We need two valid NodeIDs to add a Load edge");
-                    }
-                    else if (op.getOperator() == "StoreStmt")
-                    {
-                        if (op.getOperands().size() == 2)
-                            addStoreEdge(op.getOperands()[0], op.getOperands()[1]);
-                        else
-                            writeWrnMsg("We need two valid NodeIDs to add a Store edge");
-                    }
-                    else if (op.getOperator() == "GepStmt")
-                    {
-                        if (op.getOperands().size() == 3)
-                        {
-                            LocationSet ls(op.getOperands()[2]);
-                            addNormalGepEdge(op.getOperands()[0], op.getOperands()[1], ls);
-                        }
-                        else
-                            writeWrnMsg("We need two valid NodeIDs and an offset to add a Gep edge");
-                    }
-                    else if (op.getOperator() == "BinaryOPStmt")
-                    {
-                        if (op.getOperands().size() == 4)
-                            addBinaryOPEdge(op.getOperands()[0], op.getOperands()[1], op.getOperands()[2], op.getOperands()[3]);
-                        else
-                            writeWrnMsg("We need four valid NodeIDs to add a BinaryOP edge");
-                    }
-                    else if (op.getOperator() == "UnaryOPStmt")
-                    {
-                        if (op.getOperands().size() == 3)
-                            addUnaryOPEdge(op.getOperands()[0], op.getOperands()[1], op.getOperands()[2]);
-                        else
-                            writeWrnMsg("We need three valid NodeIDs to add a UnaryOP edge");
-                    }
-                    else if (op.getOperator() == "CmpStmt")
-                    {
-                        if (op.getOperands().size() == 4)
-                            addCmpEdge(op.getOperands()[0], op.getOperands()[1], op.getOperands()[2], op.getOperands()[3]);
-                        else
-                            writeWrnMsg("We need four valid NodeIDs to add a CmpStmt edge");
-                    }
-                    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
-                        // const SVFConstantInt* arg2 = SVFUtil::dyn_cast<SVFConstantInt>(svfcall->getArgOperand(op.getOperands()[2]));
-                        NodeID argId = pag->getValueNode(svfcall->getArgOperand(op.getOperands()[0]));
-                        std::vector<LocationSet> dstFields =  pag->getTypeLocSetsMap(argId).second;
-                        u32_t sz = dstFields.size();
-                        if (const SVFConstantInt* arg2 = SVFUtil::dyn_cast<SVFConstantInt>(svfcall->getArgOperand(op.getOperands()[2])))
-                            sz = (dstFields.size() > static_cast<u32_t>(arg2->getSExtValue())) ? arg2->getSExtValue() : dstFields.size();
-                        //For each field (i), add store edge *(arg0 + i) = arg1
-                        for (u32_t index = 0; index < sz; index++)
-                        {
-                            const SVFType* dElementType = pag->getSymbolInfo()->getFlatternedElemType(pag->getTypeLocSetsMap(argId).first, dstFields[index].getConstantFieldIdx());
-                            NodeID dField = getGepValVar(svfcall->getArgOperand(op.getOperands()[0]), dstFields[index], dElementType);
-                            addStoreEdge(pag->getValueNode(svfcall->getArgOperand(op.getOperands()[1])),dField);
-                        }
-                        if(svfcall->getType()->isPointerTy())
-                            addCopyEdge(pag->getValueNode(svfcall->getArgOperand(op.getOperands()[0])), pag->getValueNode(svfinst));
-                    }
-                    else if (op.getOperator() == "memcpy_like")
-                    {
-                        if(op.getOperands().size() == 3)
-                            addComplexConsForExt(svfcall->getArgOperand(op.getOperands()[0]), svfcall->getArgOperand(op.getOperands()[1]), svfcall->getArgOperand(op.getOperands()[2]));
-                        else
-                            addComplexConsForExt(svfcall->getArgOperand(op.getOperands()[0]), svfcall->getArgOperand(op.getOperands()[1]), nullptr);
-                    }
-                    else if (op.getOperator() == "Rb_tree_ops")
-                    {
-                        assert(svfcall->arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
-
-                        // 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(svfcall->getArgOperand(3));
-                        s32_t offset = getLocationSetFromBaseNode(vnArg3).getConstantFieldIdx();
-
-                        // We get all flattened fields of base
-                        vector<LocationSet> fields =  pag->getTypeLocSetsMap(vnArg3).second;
-
-                        // 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 SVFType* elementType = pag->getSymbolInfo()->getFlatternedElemType(pag->getTypeLocSetsMap(vnArg3).first,
-                                                         fields[i].getConstantFieldIdx());
-                            NodeID vnD = getGepValVar(svfcall->getArgOperand(3), fields[i], elementType);
-                            NodeID vnS = pag->getValueNode(svfcall->getArgOperand(1));
-                            if(vnD && vnS)
-                                addStoreEdge(vnS,vnD);
-                        }
-                    }
-                    // default
-                    // illegal function operation of external function
-                    else
-                    {
-                        assert(false && "new type of SVFStmt for external calls?");
-                    }
-                }
-            }
-        }
-
-        /// create inter-procedural SVFIR edges for thread forks
-        if (isThreadForkCall(svfinst))
-        {
-            if (const SVFFunction* forkedFun = SVFUtil::dyn_cast<SVFFunction>(getForkedFun(svfinst)))
-            {
-                forkedFun = forkedFun->getDefFunForMultipleModule();
-                const SVFValue* actualParm = getActualParmAtForkSite(svfinst);
-                /// pthread_create has 1 arg.
-                /// apr_thread_create has 2 arg.
-                assert((forkedFun->arg_size() <= 2) && "Size of formal parameter of start routine should be one");
-                if (forkedFun->arg_size() <= 2 && forkedFun->arg_size() >= 1)
-                {
-                    const SVFArgument* formalParm = forkedFun->getArg(0);
-                    /// Connect actual parameter to formal parameter of the start routine
-                    if (actualParm->getType()->isPointerTy() && formalParm->getType()->isPointerTy())
-                    {
-                        CallICFGNode *icfgNode = pag->getICFG()->getCallICFGNode(svfinst);
-                        FunEntryICFGNode *entry = pag->getICFG()->getFunEntryICFGNode(forkedFun);
-                        addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm), icfgNode, entry);
-                    }
-                }
-            }
-            else
-            {
-                /// handle indirect calls at pthread create APIs e.g., pthread_create(&t1, nullptr, fp, ...);
-                /// const Value* fun = ThreadAPI::getThreadAPI()->getForkedFun(inst);
-                /// if(!SVFUtil::isa<Function>(fun))
-                ///    pag->addIndirectCallsites(cs,pag->getValueNode(fun));
-            }
-            /// If forkedFun does not pass to spawnee as function type but as void pointer
-            /// remember to update inter-procedural callgraph/SVFIR/SVFG etc. when indirect call targets are resolved
-            /// We don't connect the callgraph here, further investigation is need to hanle mod-ref during SVFG construction.
-        }
-
-        /// create inter-procedural SVFIR edges for hare_parallel_for calls
-        else if (isHareParForCall(svfinst))
-        {
-            if (const SVFFunction* taskFunc = SVFUtil::dyn_cast<SVFFunction>(getTaskFuncAtHareParForSite(svfinst)))
-            {
-                /// The task function of hare_parallel_for has 3 args.
-                assert((taskFunc->arg_size() == 3) && "Size of formal parameter of hare_parallel_for's task routine should be 3");
-                const SVFValue* actualParm = getTaskDataAtHareParForSite(svfinst);
-                const SVFArgument* formalParm = taskFunc->getArg(0);
-                /// Connect actual parameter to formal parameter of the start routine
-                if (actualParm->getType()->isPointerTy() && formalParm->getType()->isPointerTy())
-                {
-                    CallICFGNode *icfgNode = pag->getICFG()->getCallICFGNode(svfinst);
-                    FunEntryICFGNode *entry = pag->getICFG()->getFunEntryICFGNode(taskFunc);
-                    addThreadForkEdge(pag->getValueNode(actualParm), pag->getValueNode(formalParm), icfgNode, entry);
-                }
-            }
-            else
-            {
-                /// handle indirect calls at hare_parallel_for (e.g., hare_parallel_for(..., fp, ...);
-                /// const Value* fun = ThreadAPI::getThreadAPI()->getForkedFun(inst);
-                /// if(!SVFUtil::isa<Function>(fun))
-                ///    pag->addIndirectCallsites(cs,pag->getValueNode(fun));
-            }
-        }
-
-        /// TODO: inter-procedural SVFIR edges for thread joins
-    }
-}
-
 /*!
  * Indirect call is resolved on-the-fly during pointer analysis
  */