svf-tools 1.0.533 → 1.0.536

package/include/WPA/Andersen.h

@@ -344,7 +344,7 @@ protected:
     //@}
     /// Collapse a field object into its base for field insensitive anlaysis
     //@{
-    void collapsePWCNode(NodeID nodeId);
+    virtual void collapsePWCNode(NodeID nodeId);
     void collapseFields();
     bool collapseNodePts(NodeID nodeId);
     bool collapseField(NodeID nodeId);
@@ -440,9 +440,6 @@ public:
     virtual void postProcessNode(NodeID nodeId);
     virtual bool handleLoad(NodeID id, const ConstraintEdge* load);
     virtual bool handleStore(NodeID id, const ConstraintEdge* store);
-
-protected:
-    virtual void mergeNodeToRep(NodeID nodeId,NodeID newRepId);
 };
 
 } // End namespace SVF

package/include/WPA/WPASolver.h

@@ -114,7 +114,6 @@ protected:
         while (!isWorklistEmpty())
         {
             NodeID nodeId = popFromWorklist();
-            collapsePWCNode(nodeId);
             // Keep solving until workList is empty.
             processNode(nodeId);
             collapseFields();
@@ -126,8 +125,7 @@ protected:
     /// Process each node on the graph, to be implemented in the child class
     virtual inline void processNode(NodeID) {}
     /// collapse positive weight cycles of a graph
-    virtual void collapsePWCNode(NodeID) {}
-    virtual void collapseFields() {};
+    virtual void collapseFields() {}
     /// dump statistics
     /// Propagation for the solving, to be implemented in the child class
     virtual void propagate(GNODE* v)

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -1123,76 +1123,20 @@ void SVFIRBuilder::addComplexConsForExt(Value *D, Value *S, const Value* szValue
     }
 }
 
-
-/*!
- * Get numeric index of the argument in external function
- */
-u32_t SVFIRBuilder::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 argNum = atoi(digitStr.c_str());
-    return argNum;
-}
-
-
 /*!
  * Get NodeId of s
  */
 NodeID SVFIRBuilder::parseNode(std::string s, CallSite cs, const Instruction *inst)
 {
-    Value* V = nullptr;
-    NodeID res = -1;
-    size_t argNumPre = -1;
-    bool flag = true;
-    for (size_t i = 0; i < s.size();)
-    {
-        if(!flag)
-            assert(false && "The operand format of function operation is illegal!");
-        // 'A' represents an argument
-        if (s[i] == 'A')
-        {
-            i = i + 1;
-            size_t start = i;
-            while(i < s.size() && isdigit(s[i]))
-                i++;
-            std::string digitStr = s.substr(start, i-start);
-            argNumPre = atoi(digitStr.c_str());
-            V = cs.getArgument(argNumPre);
-            if(i >= s.size())
-                res = getValueNode(V);
-        }
-        // 'R' represents a reference
-        else if(s[i] == 'R')
-        {
-            i = i + 1;
-            if(i >= s.size())
-                res = getValueNode(V);
-        }
-        // 'L' represents a return value
-        else if(s[i] == 'L')
-        {
-            res = getValueNode(inst);
-            if(i++ != 0)
-                flag = false;
-        }
-        // 'V' represents a dummy node
-        else if(s[i] == 'V')
-        {
-            res = pag->addDummyValNode();
-            if(i++ != 0)
-                flag = false;
-        }
-        else
-            flag = false;
-
-    }
-    return res;
+    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;
 }
 
 /*!
@@ -1238,206 +1182,243 @@ void SVFIRBuilder::handleExtCall(CallSite cs, const SVFFunction *callee)
         if (isExtCall(callee))
         {
             std::string funName = ExtAPI::getExtAPI()->get_name(callee);
-            cJSON *item = ExtAPI::getExtAPI()->get_FunJson(funName);
-            // The external function exists in ExtAPI.json
-            if (item != nullptr)
+            std::vector<std::vector<ExtAPI::Operation *>> allOperations = ExtAPI::getExtAPI()->getAllOperations(funName);
+            if (allOperations.size() == 0)
+            {
+                std::string str;
+                raw_string_ostream rawstr(str);
+                rawstr << "function " << callee->getName() << " not in the external function summary ExtAPI.json file";
+                writeWrnMsg(rawstr.str());
+            }
+            else
             {
-                cJSON *obj = item->child;
-                //  Get the first operation of the function
-                obj = obj -> next -> next;
-                while (obj)
+                for (auto operations: allOperations)
                 {
-                    std::string op = obj->string;
-                    std::vector<std::string> args;
-                    if (obj->type == cJSON_Array)
+                    NodeID tempNode = -1;
+                    // Record the previous operation
+                    ExtAPI::Operation *preOp = nullptr;
+                    for (auto op : operations)
                     {
-                        // Get the first argument of the operation
-                        cJSON *value = obj->child;
-                        args = ExtAPI::getExtAPI()->get_opArgs(value);
-                        obj = obj->next;
-                    }
-                    else
-                    {
-                        assert(false && "The function operation format is illegal!");
-                    }
-
-                    ExtAPI::extf_t opName = ExtAPI::getExtAPI()->get_opName(op);
+                        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)
+                        switch (opName)
+                        {
+                        case ExtAPI::EXT_ADDR:
                         {
-                            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)))
+                            if (args.size() == 1)
                             {
-                                NodeID val = parseNode(args[0], cs, inst);
-                                NodeID obj = getObjectNode(inst);
-                                addAddrEdge(obj, val);
+                                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;
                         }
-                        break;
-                    }
-                    case ExtAPI::EXT_COPY:
-                    {
-                        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);
-                        break;
-                    }
-                    case ExtAPI::EXT_STORE:
-                    {
-                        NodeID vnS = parseNode(args[0], cs, inst);
-                        NodeID vnD = parseNode(args[1], cs, inst);
-                        if (vnS && vnD)
-                            addStoreEdge(vnS, vnD);
-                        break;
-                    }
-                    case ExtAPI::EXT_LOADSTORE:
-                    {
-                        NodeID vnS = parseNode(args[0], cs, inst);
-                        NodeID vnV = parseNode(args[1], cs, inst);
-                        NodeID vnD = parseNode(args[2], cs, inst);
-                        if (vnD && vnV && vnS)
+                        case ExtAPI::EXT_COPY:
                         {
-                            addLoadEdge(vnS, vnV);
-                            addStoreEdge(vnV, vnD);
+                            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;
                         }
-                        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 = getArgPos(args[0]);
-                        u32_t arg_posB = getArgPos(args[1]);
-                        u32_t arg_posC = 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++)
+                        case ExtAPI::EXT_LOAD:
                         {
-                            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);
+                            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;
                         }
-                        if (SVFUtil::isa<PointerType>(inst->getType()))
-                            addCopyEdge(getValueNode(cs.getArgument(arg_posA)), getValueNode(inst));
-                        break;
-                    }
-                    case ExtAPI::EXT_COPY_MN:
-                    {
-                        u32_t arg_posA = getArgPos(args[0]);
-                        u32_t arg_posB = getArgPos(args[1]);
-                        if (args.size() >= 3)
+                        case ExtAPI::EXT_STORE:
                         {
-                            u32_t arg_posC = getArgPos(args[2]);
-                            addComplexConsForExt(cs.getArgument(arg_posA), cs.getArgument(arg_posB), cs.getArgument(arg_posC));
+                            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;
                         }
-                        else
-                            addComplexConsForExt(cs.getArgument(arg_posA), cs.getArgument(arg_posB), nullptr);
-                        break;
-                    }
-                    case ExtAPI::EXT_FUNPTR:
-                    {
-                        /// handling external function e.g., void *dlsym(void *handle, const char *funname);
-                        u32_t arg_posA = 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))
+                        case ExtAPI::EXT_GEP:
                         {
-                            if (const ConstantDataArray *constarray = SVFUtil::dyn_cast<ConstantDataArray>(glob->getInitializer()))
+                            // "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
                             {
-                                if (const SVFFunction *fun = getProgFunction(svfMod, constarray->getAsCString().str()))
+                                NodeID vnS = parseNode(args[0], cs, inst);
+                                NodeID vnD = parseNode(args[1], cs, inst);
+                                u32_t offset = stoul(args[2]);
+                                if (vnD && vnS)
                                 {
-                                    NodeID srcNode = getValueNode(fun->getLLVMFun());
-                                    addCopyEdge(srcNode, getValueNode(inst));
+                                    LocationSet ls(offset);
+                                    addNormalGepEdge(vnS, vnD, ls);
                                 }
                             }
+                            break;
                         }
-                        break;
-                    }
-                    case ExtAPI::EXT_COMPLEX:
-                    {
-                        assert(cs.arg_size() == 4 && "_Rb_tree_insert_and_rebalance should have 4 arguments.\n");
-                        Value *argA = cs.getArgument(getArgPos(args[0]));
-                        Value *argB = cs.getArgument(getArgPos(args[1]));
-
-                        // 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 get all flattened fields of base
-                        vector<LocationSet> fields;
-                        const Type *type = getBaseTypeAndFlattenedFields(argB, 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)
+                        case ExtAPI::EXT_COPY_N:
                         {
-                            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);
+                            // 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;
                         }
-                        break;
-                    }
-                    case ExtAPI::EXT_GEPGEP:
-                    {
-                        NodeID vnS = parseNode(args[0], cs, inst);
-                        u32_t offset1 = stoul(args[1]);
-                        NodeID vnV = parseNode(args[2], cs, inst);
-                        u32_t offset2 = stoul(args[3]);
-                        NodeID vnD = parseNode(args[4], cs, inst);
-                        if (vnD && vnV && vnS)
+                        case ExtAPI::EXT_COPY_MN:
                         {
-                            LocationSet l1(offset1);
-                            LocationSet l2(offset2);
-                            addNormalGepEdge(vnS, vnV, l1);
-                            addNormalGepEdge(vnV, vnD, l2);
+                            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;
+                        }
+                        case ExtAPI::EXT_FUNPTR:
+                        {
+                            /// 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 SVFFunction *fun = getProgFunction(svfMod, constarray->getAsCString().str()))
+                                    {
+                                        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");
+
+                            Value *argA = cs.getArgument(ExtAPI::getExtAPI()->getArgPos(args[0]));
+                            Value *argB = cs.getArgument(ExtAPI::getExtAPI()->getArgPos(args[1]));
+
+                            // 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 get all flattened fields of base
+                            vector<LocationSet> fields;
+                            const Type *type = getBaseTypeAndFlattenedFields(argB, 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:
+                        {
+                            assert(false && "new type of SVFStmt for external calls?");
+                        }
                         }
-                        break;
-                    }
-                    // default
-                    // illegal function operation of external function
-                    case ExtAPI::EXT_OTHER:
-                    default:
-                    {
-                        assert(false && "new type of SVFStmt for external calls?");
-                    }
                     }
+                    for(u32_t it = 0; it != operations.size(); ++it)
+                        delete operations[it];
+                    operations.clear();
                 }
             }
-            // // The external function doesn't exist in ExtAPI.json
-            else
-            {
-                std::string str;
-                raw_string_ostream rawstr(str);
-                rawstr << "function " << callee->getName() << " not in the external function summary ExtAPI.json file";
-                writeWrnMsg(rawstr.str());
-            }
+            allOperations.clear();
         }
 
         /// create inter-procedural SVFIR edges for thread forks

package/lib/Util/ExtAPI.cpp

@@ -224,6 +224,48 @@ const std::string& ExtAPI::extType_toString(extType type)
     return it->first;
 }
 
+// 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 argNum = atoi(digitStr.c_str());
+    return argNum;
+}
+
+// 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
+int ExtAPI::getNodeIDType(std::string s)
+{
+    size_t argPos = -1;
+    // 'A' represents an argument
+    if (s.size() == 0)
+        return -3;
+    if (s[0] == 'A')
+    {
+        size_t start = 1;
+        size_t end = 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')
+        return -1;
+    if(s[0] == 'D')
+        return -2;
+
+    return -3;
+}
+
 // Get external function name, e.g "memcpy"
 std::string ExtAPI::get_name(const SVFFunction *F)
 {
@@ -245,6 +287,73 @@ cJSON *ExtAPI::get_FunJson(const std::string &funName)
     return cJSON_GetObjectItemCaseSensitive(root, funName.c_str());
 }
 
+// Get all operations of an extern function
+std::vector<std::vector<ExtAPI::Operation *>> ExtAPI::getAllOperations(std::string funName)
+{
+    std::vector<std::vector<ExtAPI::Operation *>> allOperations;
+    cJSON *item = get_FunJson(funName);
+    if (item != nullptr)
+    {
+        cJSON *obj = item->child;
+        //  Get the first operation of the function
+        obj = obj -> next -> next;
+        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)
+            {
+                if (obj->type == cJSON_Object)
+                {
+                    cJSON *value = obj->child;
+                    while (value)
+                    {
+                        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;
+                    }
+                }
+            }
+            // 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);
+            operations.clear();
+
+            obj = obj -> next;
+        }
+    }
+    return allOperations;
+}
+
 // Get arguments of the operation, e.g. ["A1R", "A0", "A2"]
 std::vector<std::string> ExtAPI::get_opArgs(const cJSON *value)
 {