svf-tools 1.0.694 → 1.0.696

package/svf/lib/SVFIR/SVFIRRW.cpp

@@ -2,6 +2,11 @@
 #include "Graphs/CHG.h"
 #include "SVFIR/SVFIR.h"
 #include "Util/CommandLine.h"
+#include <sys/fcntl.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 static const Option<bool> humanReadableOption(
     "human-readable", "Whether to output human-readable JSON", true);
@@ -9,6 +14,95 @@ static const Option<bool> humanReadableOption(
 namespace SVF
 {
 
+SVFType* createSVFType(SVFType::GNodeK kind, bool isSingleValTy)
+{
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible SVFTyKind in create()");
+    case SVFType::SVFTy:
+        ABORT_MSG("Creation of RAW SVFType isn't allowed");
+    case SVFType::SVFPointerTy:
+        ABORT_IFNOT(isSingleValTy, "Pointer type must be single-valued");
+        return new SVFPointerType(nullptr);
+    case SVFType::SVFIntegerTy:
+        ABORT_IFNOT(isSingleValTy, "Integer type must be single-valued");
+        return new SVFIntegerType();
+    case SVFType::SVFFunctionTy:
+        ABORT_IFNOT(!isSingleValTy, "Function type must be multi-valued");
+        return new SVFFunctionType(nullptr);
+    case SVFType::SVFStructTy:
+        ABORT_IFNOT(!isSingleValTy, "Struct type must be multi-valued");
+        return new SVFStructType();
+    case SVFType::SVFArrayTy:
+        ABORT_IFNOT(!isSingleValTy, "Array type must be multi-valued");
+        return new SVFArrayType();
+    case SVFType::SVFOtherTy:
+        return new SVFOtherType(isSingleValTy);
+    }
+}
+
+static SVFValue* createSVFValue(SVFValue::GNodeK kind, const SVFType* type,
+                                const std::string& name)
+{
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible SVFValueKind in create()");
+    case SVFValue::SVFVal:
+        ABORT_MSG("Creation of RAW SVFValue isn't allowed");
+    case SVFValue::SVFFunc:
+        return new SVFFunction(name, type, {}, {}, {}, {}, {}, {});
+    case SVFValue::SVFBB:
+        return new SVFBasicBlock(name, type, {});
+    case SVFValue::SVFInst:
+        return new SVFInstruction(name, type, {}, {}, {});
+    case SVFValue::SVFCall:
+        return new SVFCallInst(name, type, {}, {}, {});
+    case SVFValue::SVFVCall:
+        return new SVFVirtualCallInst(name, type, {}, {}, {});
+    case SVFValue::SVFGlob:
+        return new SVFGlobalValue(name, type);
+    case SVFValue::SVFArg:
+        return new SVFArgument(name, type, {}, {}, {});
+    case SVFValue::SVFConst:
+        return new SVFConstant(name, type);
+    case SVFValue::SVFConstData:
+        return new SVFConstantData(name, type);
+    case SVFValue::SVFConstInt:
+        return new SVFConstantInt(name, type, {}, {});
+    case SVFValue::SVFConstFP:
+        return new SVFConstantFP(name, type, {});
+    case SVFValue::SVFNullPtr:
+        return new SVFConstantNullPtr(name, type);
+    case SVFValue::SVFBlackHole:
+        return new SVFBlackHoleValue(name, type);
+    case SVFValue::SVFMetaAsValue:
+        return new SVFMetadataAsValue(name, type);
+    case SVFValue::SVFOther:
+        return new SVFOtherValue(name, type);
+    }
+}
+
+template <typename SmallNumberType>
+static inline void readSmallNumber(const cJSON* obj, SmallNumberType& val)
+{
+    val = static_cast<SmallNumberType>(jsonGetNumber(obj));
+}
+
+template <typename BigNumberType, typename CStrToVal>
+static inline void readBigNumber(const cJSON* obj, BigNumberType& val, CStrToVal conv)
+{
+    ABORT_IFNOT(jsonIsString(obj),
+                "Expect (number) string JSON for " << JSON_KEY(obj));
+    val = conv(obj->valuestring);
+}
+
+cJSON* SVFIRWriter::toJson(bool flag)
+{
+    return jsonCreateBool(flag);
+}
+
 cJSON* SVFIRWriter::toJson(unsigned number)
 {
     // OK, double precision enough
@@ -21,6 +115,11 @@ cJSON* SVFIRWriter::toJson(int number)
     return jsonCreateNumber(number);
 }
 
+cJSON* SVFIRWriter::toJson(const std::string& str)
+{
+    return jsonCreateString(str.c_str());
+}
+
 cJSON* SVFIRWriter::toJson(float number)
 {
     return jsonCreateNumber(number);
@@ -53,7 +152,7 @@ cJSON* SVFIRWriter::virtToJson(const SVFType* type)
 
 #define CASE(Kind)                                                             \
     case SVFType::Kind:                                                        \
-        return contentToJson(SVFUtil::dyn_cast<Kind##pe>(type))
+        return contentToJson(static_cast<const Kind##pe*>(type))
 
         CASE(SVFTy);
         CASE(SVFPointerTy);
@@ -372,9 +471,9 @@ cJSON* SVFIRWriter::contentToJson(const SVFType* type)
 {
     cJSON* root = jsonCreateObject();
     JSON_WRITE_FIELD(root, type, kind);
+    JSON_WRITE_FIELD(root, type, isSingleValTy);
     JSON_WRITE_FIELD(root, type, getPointerToTy);
     JSON_WRITE_FIELD(root, type, typeinfo);
-    JSON_WRITE_FIELD(root, type, isSingleValTy);
     return root;
 }
 
@@ -416,29 +515,30 @@ cJSON* SVFIRWriter::contentToJson(const SVFValue* value)
 {
     cJSON* root = jsonCreateObject();
     JSON_WRITE_FIELD(root, value, kind);
-    JSON_WRITE_FIELD(root, value, ptrInUncalledFun);
-    JSON_WRITE_FIELD(root, value, constDataOrAggData);
     JSON_WRITE_FIELD(root, value, type);
     JSON_WRITE_FIELD(root, value, name);
+    JSON_WRITE_FIELD(root, value, ptrInUncalledFun);
+    JSON_WRITE_FIELD(root, value, constDataOrAggData);
     JSON_WRITE_FIELD(root, value, sourceLoc);
-
     return root;
 }
 
 cJSON* SVFIRWriter::contentToJson(const SVFFunction* value)
 {
     cJSON* root = contentToJson(static_cast<const SVFValue*>(value));
-    JSON_WRITE_FIELD(root, value, isDecl);
-    JSON_WRITE_FIELD(root, value, intrinsic);
-    JSON_WRITE_FIELD(root, value, addrTaken);
-    JSON_WRITE_FIELD(root, value, isUncalled);
-    JSON_WRITE_FIELD(root, value, isNotRet);
-    JSON_WRITE_FIELD(root, value, varArg);
-    JSON_WRITE_FIELD(root, value, funcType);
-    JSON_WRITE_FIELD(root, value, loopAndDom);
-    JSON_WRITE_FIELD(root, value, realDefFun);
-    JSON_WRITE_FIELD(root, value, allBBs);
-    JSON_WRITE_FIELD(root, value, allArgs);
+#define F(f) JSON_WRITE_FIELD(root, value, f);
+    F(isDecl);
+    F(intrinsic);
+    F(addrTaken);
+    F(isUncalled);
+    F(isNotRet);
+    F(varArg);
+    F(funcType);
+    F(loopAndDom);
+    F(realDefFun);
+    F(allBBs);
+    F(allArgs);
+#undef F
     return root;
 }
 
@@ -566,35 +666,6 @@ cJSON* SVFIRWriter::contentToJson(const SVFLoop* loop)
     return root;
 }
 
-cJSON* SVFIRWriter::contentToJson(const SymbolTableInfo* symTable)
-{
-    // Owns values of objMap & svfTypes (?)
-    cJSON* root = jsonCreateObject();
-    JSON_WRITE_FIELD(root, symTable, valSymMap);
-    JSON_WRITE_FIELD(root, symTable, objSymMap);
-    JSON_WRITE_FIELD(root, symTable, returnSymMap);
-    JSON_WRITE_FIELD(root, symTable, varargSymMap);
-
-    // objMap
-    cJSON* objMap = jsonCreateMap();
-    for (const auto &pair : symTable->objMap)
-    {
-        SymID id = pair.first;
-        const MemObj* memObj = pair.second;
-
-        cJSON* keyJson = toJson(id);
-        cJSON* valueJson = contentToJson(memObj);
-        jsonAddPairToMap(objMap, keyJson, valueJson);
-    }
-    jsonAddItemToObject(root, "objMap", objMap);
-
-    // TODO: Check symTable->module == module
-    JSON_WRITE_FIELD(root, symTable, modelConstants);
-    JSON_WRITE_FIELD(root, symTable, totalSymNum);
-    JSON_WRITE_FIELD(root, symTable, svfTypes);
-    return root;
-}
-
 cJSON* SVFIRWriter::contentToJson(const AssignStmt* edge)
 {
     return contentToJson(static_cast<const SVFStmt*>(edge));
@@ -717,15 +788,45 @@ bool jsonAddStringToObject(cJSON* obj, const char* name, const char* str)
     return jsonAddItemToObject(obj, name, node);
 }
 
-bool jsonAddStringToObject(cJSON* obj, const char* name, const std::string& str)
+bool jsonAddStringToObject(cJSON* obj, const char* name, const std::string& s)
 {
-    return jsonAddStringToObject(obj, name, str.c_str());
+    return jsonAddStringToObject(obj, name, s.c_str());
 }
 
-cJSON* jsonCreateNullId()
+bool jsonIsBool(const cJSON* item)
 {
-    // TODO: optimize
-    return cJSON_CreateNull();
+    return humanReadableOption()
+           ? cJSON_IsBool(item)
+           : cJSON_IsNumber(item) &&
+           (item->valuedouble == 0 || item->valuedouble == 1);
+}
+
+bool jsonIsBool(const cJSON* item, bool& flag)
+{
+    if (humanReadableOption())
+    {
+        if (!cJSON_IsBool(item))
+            return false;
+        flag = cJSON_IsTrue(item);
+        return true;
+    }
+    else
+    {
+        if (!cJSON_IsNumber(item))
+            return false;
+        flag = item->valuedouble == 1;
+        return true;
+    }
+}
+
+bool jsonIsNumber(const cJSON* item)
+{
+    return cJSON_IsNumber(item);
+}
+
+bool jsonIsString(const cJSON* item)
+{
+    return cJSON_IsString(item);
 }
 
 bool jsonIsNullId(const cJSON* item)
@@ -734,6 +835,49 @@ bool jsonIsNullId(const cJSON* item)
     return cJSON_IsNull(item);
 }
 
+bool jsonIsArray(const cJSON* item)
+{
+    return cJSON_IsArray(item);
+}
+
+bool jsonIsMap(const cJSON* item)
+{
+    return cJSON_IsArray(item);
+}
+
+bool jsonIsObject(const cJSON* item)
+{
+    return humanReadableOption() ? cJSON_IsObject(item) : cJSON_IsArray(item);
+}
+
+bool jsonKeyEquals(const cJSON* item, const char* key)
+{
+    return item && !(humanReadableOption() && std::strcmp(item->string, key));
+}
+
+std::pair<const cJSON*,const cJSON*> jsonUnpackPair(const cJSON* item)
+{
+    ABORT_IFNOT(jsonIsArray(item), "Expected array as pair");
+    cJSON* child1 = item->child;
+    ABORT_IFNOT(child1, "Missing first child of pair");
+    cJSON* child2 = child1->next;
+    ABORT_IFNOT(child2, "Missing first child of pair");
+    ABORT_IFNOT(!child2->next, "Pair has more than two children");
+    return {child1, child2};
+}
+
+double jsonGetNumber(const cJSON* item)
+{
+    ABORT_IFNOT(jsonIsNumber(item), "Expected number for " << JSON_KEY(item));
+    return item->valuedouble;
+}
+
+cJSON* jsonCreateNullId()
+{
+    // TODO: optimize
+    return cJSON_CreateNull();
+}
+
 cJSON* jsonCreateObject()
 {
     return humanReadableOption() ? cJSON_CreateObject() : cJSON_CreateArray();
@@ -763,6 +907,12 @@ cJSON* jsonCreateIndex(size_t index)
     return cJSON_CreateNumber(index);
 }
 
+cJSON* jsonCreateBool(bool flag)
+{
+    bool hr = humanReadableOption();
+    return hr ? cJSON_CreateBool(flag) : cJSON_CreateNumber(flag);
+}
+
 cJSON* jsonCreateNumber(double num)
 {
     return cJSON_CreateNumber(num);
@@ -799,40 +949,34 @@ ICFGWriter::ICFGWriter(const ICFG* icfg) : GenericICFGWriter(icfg)
     }
 }
 
-SymID SymbolTableInfoWriter::getMemObjID(const MemObj* memObj)
-{
-    auto it = memObjToID.find(memObj);
-    assert(it != memObjToID.end() && "MemObj not found!");
-    return it->second;
-}
-
-SymbolTableInfoWriter::SymbolTableInfoWriter(const SymbolTableInfo* symTab)
-    : symbolTableInfo(symTab)
+SVFModuleWriter::SVFModuleWriter(const SVFModule* svfModule)
 {
-    assert(symbolTableInfo && "SymbolTableInfo is null!");
+    // TODO: SVFType & StInfo are managed by SymbolTableInfo. Refactor it?
+    auto symTab = SymbolTableInfo::SymbolInfo();
 
-    for (const auto& pair : symbolTableInfo->idToObjMap())
+    const auto& svfTypes = symTab->getSVFTypes();
+    svfTypePool.reserve(svfTypes.size());
+    for (const SVFType* type : svfTypes)
     {
-        const SymID id = pair.first;
-        const MemObj* obj = pair.second;
-        memObjToID.emplace(obj, id);
+        svfTypePool.saveID(type);
     }
-}
 
-size_t SVFModuleWriter::getSvfTypeID(const SVFType* type)
-{
-    return svfTypePool.getID(type);
-}
+    const auto& stInfos = symTab->getStInfos();
+    stInfoPool.reserve(stInfos.size());
+    for (const StInfo* stInfo : stInfos)
+    {
+        stInfoPool.saveID(stInfo);
+    }
 
-size_t SVFModuleWriter::getSvfValueID(const SVFValue* value)
-{
-    return svfValuePool.getID(value);
+    svfValuePool.reserve(svfModule->getFunctionSet().size() +
+                         svfModule->getConstantSet().size() +
+                         svfModule->getOtherValueSet().size());
 }
 
 SVFIRWriter::SVFIRWriter(const SVFIR* svfir)
-    : svfIR(svfir), irGraphWriter(svfir), icfgWriter(svfir->icfg),
+    : svfIR(svfir), svfModuleWriter(svfir->svfModule), icfgWriter(svfir->icfg),
       chgWriter(SVFUtil::dyn_cast<CHGraph>(svfir->chgraph)),
-      symbolTableInfoWriter(svfir->symInfo)
+      irGraphWriter(svfir)
 {
 }
 
@@ -877,9 +1021,15 @@ SVFIRWriter::autoCStr SVFIRWriter::generateJsonString()
 
 SVFIRWriter::autoJSON SVFIRWriter::generateJson()
 {
-    cJSON* root = jsonCreateObject();
+    const IRGraph* const irGraph = svfIR;
 
+    cJSON* root = jsonCreateObject();
 #define F(field) JSON_WRITE_FIELD(root, svfIR, field)
+    F(svfModule);
+    F(symInfo);
+    F(icfg);
+    F(chgraph);
+    jsonAddJsonableToObject(root, FIELD_NAME_ITEM(irGraph));
     F(icfgNode2SVFStmtsMap);
     F(icfgNode2PTASVFStmtsMap);
     F(GepValObjMap);
@@ -894,11 +1044,7 @@ SVFIRWriter::autoJSON SVFIRWriter::generateJson()
     F(indCallSiteToFunPtrMap);
     F(funPtrToCallSitesMap);
     F(candidatePointers);
-    F(icfg);
-    F(chgraph);
     F(callSiteSet);
-
-    F(svfModule); // Keep this last one
 #undef F
 
     return {root, cJSON_Delete};
@@ -906,12 +1052,12 @@ SVFIRWriter::autoJSON SVFIRWriter::generateJson()
 
 cJSON* SVFIRWriter::toJson(const SVFType* type)
 {
-    return jsonCreateIndex(svfModuleWriter.getSvfTypeID(type));
+    return jsonCreateIndex(svfModuleWriter.getSVFTypeID(type));
 }
 
 cJSON* SVFIRWriter::toJson(const SVFValue* value)
 {
-    return jsonCreateIndex(svfModuleWriter.getSvfValueID(value));
+    return jsonCreateIndex(svfModuleWriter.getSVFValueID(value));
 }
 
 cJSON* SVFIRWriter::toJson(const IRGraph* graph)
@@ -926,15 +1072,13 @@ cJSON* SVFIRWriter::toJson(const IRGraph* graph)
     F(nodeNumAfterPAGBuild);
     F(totalPTAPAGEdge);
     F(valueToEdgeMap);
-    jsonAddContentToObject(root, "symInfo", graph->symInfo);
 #undef F
     return root;
 }
 
 cJSON* SVFIRWriter::toJson(const SVFVar* var)
 {
-    return var ? jsonCreateIndex(irGraphWriter.getNodeID(var))
-           : jsonCreateNullId();
+    return var ? jsonCreateIndex(var->getId()) : jsonCreateNullId();
 }
 
 cJSON* SVFIRWriter::toJson(const SVFStmt* stmt)
@@ -944,9 +1088,17 @@ cJSON* SVFIRWriter::toJson(const SVFStmt* stmt)
 
 cJSON* SVFIRWriter::toJson(const ICFG* icfg)
 {
-    cJSON* root = genericGraphToJson(icfg, icfgWriter.edgePool.getPool());
+    cJSON* allSvfLoop = jsonCreateArray(); // all indices seen in constructor
+    for (const SVFLoop* svfLoop : icfgWriter.svfLoopPool)
+    {
+        cJSON* svfLoopObj = contentToJson(svfLoop);
+        jsonAddItemToArray(allSvfLoop, svfLoopObj);
+    }
 
 #define F(field) JSON_WRITE_FIELD(root, icfg, field)
+    cJSON* root = genericGraphToJson(icfg, icfgWriter.edgePool.getPool());
+    jsonAddItemToObject(root, FIELD_NAME_ITEM(allSvfLoop)); // Meta field
+    F(totalICFGNode);
     F(FunToFunEntryNodeMap);
     F(FunToFunExitNodeMap);
     F(CSToCallNodeMap);
@@ -960,11 +1112,13 @@ cJSON* SVFIRWriter::toJson(const ICFG* icfg)
 
 cJSON* SVFIRWriter::toJson(const ICFGNode* node)
 {
-    return jsonCreateIndex(icfgWriter.getNodeID(node));
+    assert(node && "ICFGNode is null!");
+    return jsonCreateIndex(node->getId());
 }
 
 cJSON* SVFIRWriter::toJson(const ICFGEdge* edge)
 {
+    assert(edge && "ICFGNode is null!");
     return jsonCreateIndex(icfgWriter.getEdgeID(edge));
 }
 
@@ -998,7 +1152,7 @@ cJSON* SVFIRWriter::toJson(const CHGraph* graph)
 
 cJSON* SVFIRWriter::toJson(const CHNode* node)
 {
-    return jsonCreateIndex(chgWriter.getNodeID(node));
+    return jsonCreateIndex(node->getId());
 }
 
 cJSON* SVFIRWriter::toJson(const CHEdge* edge)
@@ -1019,9 +1173,24 @@ cJSON* SVFIRWriter::toJson(const SVFLoop* loop)
 cJSON* SVFIRWriter::contentToJson(const MemObj* memObj)
 {
     cJSON* root = jsonCreateObject();
-    JSON_WRITE_FIELD(root, memObj, typeInfo); // Owns this pointer
-    JSON_WRITE_FIELD(root, memObj, refVal);
     JSON_WRITE_FIELD(root, memObj, symId);
+    JSON_WRITE_FIELD(root, memObj, typeInfo);
+    JSON_WRITE_FIELD(root, memObj, refVal);
+    return root;
+}
+
+cJSON* SVFIRWriter::contentToJson(const StInfo* stInfo)
+{
+    cJSON* root = jsonCreateObject();
+#define F(field) JSON_WRITE_FIELD(root, stInfo, field)
+    F(stride);
+    F(fldIdxVec);
+    F(elemIdxVec);
+    F(fldIdx2TypeMap);
+    F(finfo);
+    F(numOfFlattenElements);
+    F(flattenElementTypes);
+#undef F
     return root;
 }
 
@@ -1034,16 +1203,12 @@ cJSON* SVFIRWriter::toJson(const ObjTypeInfo* objTypeInfo)
     JSON_WRITE_FIELD(root, objTypeInfo, flags);
     JSON_WRITE_FIELD(root, objTypeInfo, maxOffsetLimit);
     JSON_WRITE_FIELD(root, objTypeInfo, elemNum);
-    JSON_WRITE_FIELD(root, objTypeInfo, type);
-    JSON_WRITE_FIELD(root, objTypeInfo, flags);
-    JSON_WRITE_FIELD(root, objTypeInfo, maxOffsetLimit);
-    JSON_WRITE_FIELD(root, objTypeInfo, elemNum);
     return root;
 }
 
 cJSON* SVFIRWriter::toJson(const MemObj* memObj)
 {
-    return jsonCreateIndex(symbolTableInfoWriter.getMemObjID(memObj));
+    return jsonCreateIndex(memObj->getId());
 }
 
 cJSON* SVFIRWriter::toJson(const SVFLoopAndDomInfo* ldInfo)
@@ -1059,21 +1224,9 @@ cJSON* SVFIRWriter::toJson(const SVFLoopAndDomInfo* ldInfo)
     return root;
 }
 
-cJSON* SVFIRWriter::toJson(const StInfo* type)
+cJSON* SVFIRWriter::toJson(const StInfo* stInfo)
 {
-    ENSURE_NOT_VISITED(type);
-
-    cJSON* root = jsonCreateObject();
-#define F(field) JSON_WRITE_FIELD(root, type, field)
-    F(fldIdxVec);
-    F(elemIdxVec);
-    F(fldIdx2TypeMap);
-    F(finfo);
-    F(stride);
-    F(numOfFlattenElements);
-    F(flattenElementTypes);
-#undef F
-    return root;
+    return jsonCreateIndex(svfModuleWriter.getStInfoID(stInfo));
 }
 
 cJSON* SVFIRWriter::toJson(const LocationSet& ls)
@@ -1084,36 +1237,1265 @@ cJSON* SVFIRWriter::toJson(const LocationSet& ls)
     return root;
 }
 
-cJSON* SVFIRWriter::toJson(const SVFModule* module)
+cJSON* SVFIRWriter::toJson(const SymbolTableInfo* symTable)
 {
+    ENSURE_NOT_VISITED(symTable);
+
     cJSON* root = jsonCreateObject();
+    cJSON* allMemObj = jsonCreateArray();
+    for (const auto& pair : symTable->objMap)
+    {
+        const MemObj* memObj = pair.second;
+        cJSON* memObjJson = contentToJson(memObj);
+        jsonAddItemToArray(allMemObj, memObjJson);
+    }
 
-    JSON_WRITE_FIELD(root, module, pagReadFromTxt);
-    JSON_WRITE_FIELD(root, module, moduleIdentifier);
+#define F(field) JSON_WRITE_FIELD(root, symTable, field)
+    jsonAddItemToObject(root, FIELD_NAME_ITEM(allMemObj)); // Actual field
+
+    F(valSymMap);
+    F(objSymMap);
+    F(returnSymMap);
+    F(varargSymMap);
+    // Field objMap can be represented by allMemObj
+    // Field mod can be represented by svfIR->svfModule. Delete it?
+    assert(symTable->mod == svfIR->svfModule && "SVFModule mismatch!");
+    F(modelConstants);
+    F(totalSymNum);
+    F(maxStruct);
+    F(maxStSize);
+    // Field svfTypes can be represented by svfModuleWriter.svfTypePool
+    // Field stInfos can be represented by svfModuleWriter.stInfoPool
+#undef F
+
+    return root;
+}
+
+cJSON* SVFIRWriter::toJson(const SVFModule* module)
+{
+    cJSON* root = jsonCreateObject();
+    cJSON* allSVFType = jsonCreateArray();
+    cJSON* allStInfo = jsonCreateArray();
+    cJSON* allSVFValue = jsonCreateArray();
 
-    JSON_WRITE_FIELD(root, module, FunctionSet);
-    JSON_WRITE_FIELD(root, module, GlobalSet);
-    JSON_WRITE_FIELD(root, module, AliasSet);
-    JSON_WRITE_FIELD(root, module, ConstantSet);
-    JSON_WRITE_FIELD(root, module, OtherValueSet);
+    for (const SVFType* svfType : svfModuleWriter.svfTypePool)
+    {
+        cJSON* svfTypeObj = virtToJson(svfType);
+        jsonAddItemToArray(allSVFType, svfTypeObj);
+    }
 
-    cJSON* values = jsonCreateArray();
-    for (size_t i = 1; i <= svfModuleWriter.svfValuePool.size(); ++i)
+    for (const StInfo* stInfo : svfModuleWriter.stInfoPool)
     {
-        cJSON* value = contentToJson(svfModuleWriter.svfValuePool.getPtr(i));
-        jsonAddItemToArray(values, value);
+        cJSON* stInfoObj = contentToJson(stInfo);
+        jsonAddItemToArray(allStInfo, stInfoObj);
     }
-    jsonAddItemToObject(root, "values", values);
 
-    cJSON* types = jsonCreateArray();
-    for (size_t i = 1; i <= svfModuleWriter.svfTypePool.size(); ++i)
+#define F(field) JSON_WRITE_FIELD(root, module, field)
+    jsonAddItemToObject(root, FIELD_NAME_ITEM(allSVFType));  // Meta field
+    jsonAddItemToObject(root, FIELD_NAME_ITEM(allStInfo));   // Meta field
+    jsonAddItemToObject(root, FIELD_NAME_ITEM(allSVFValue)); // Meta field
+    F(pagReadFromTxt);
+    F(moduleIdentifier);
+
+    F(FunctionSet);
+    F(GlobalSet);
+    F(AliasSet);
+    F(ConstantSet);
+    F(OtherValueSet);
+#undef F
+
+    for (size_t i = 1; i <= svfModuleWriter.sizeSVFValuePool(); ++i)
     {
-        cJSON* type = contentToJson(svfModuleWriter.svfTypePool.getPtr(i));
-        jsonAddItemToArray(types, type);
+        cJSON* value = virtToJson(svfModuleWriter.getSVFValuePtr(i));
+        jsonAddItemToArray(allSVFValue, value);
     }
-    jsonAddItemToObject(root, "types", types);
 
     return root;
 }
 
-} // namespace SVF
+SVFIR* SVFIRReader::read(const cJSON* root)
+{
+    const cJSON* svfirField = createObjs(root);
+
+    SVFIR* svfIR = SVFIR::getPAG(); // SVFIR constructor sets symInfo
+    IRGraph* irGraph = svfIR;
+
+    auto svfModule = new SVFModule();
+    auto icfg = new ICFG();
+    auto chgraph = new CHGraph(svfModule);
+    auto symboTableInfo = SymbolTableInfo::SymbolInfo();
+
+    svfIR->svfModule = svfModule;
+    svfIR->icfg = icfg;
+    svfIR->chgraph = chgraph;
+
+#define F(field) JSON_READ_FIELD_FWD(svfirField, svfIR, field)
+    readJson(symboTableInfo);
+    readJson(irGraph);
+    readJson(icfg);
+    readJson(chgraph);
+    readJson(svfModule);
+
+    F(icfgNode2SVFStmtsMap);
+    F(icfgNode2PTASVFStmtsMap);
+    F(GepValObjMap);
+    F(GepObjVarMap);
+    F(memToFieldsMap);
+    F(globSVFStmtSet);
+    F(phiNodeMap);
+    F(funArgsListMap);
+    F(callSiteArgsListMap);
+    F(callSiteRetMap);
+    F(funRetMap);
+    F(indCallSiteToFunPtrMap);
+    F(funPtrToCallSitesMap);
+    F(candidatePointers);
+    F(callSiteSet);
+#undef F
+
+    return svfIR;
+}
+
+const cJSON* SVFIRReader::createObjs(const cJSON* root)
+{
+#define READ_CREATE_NODE_FWD(GType)                                            \
+    [](const cJSON*& nodeJson) {                                               \
+        JSON_DEF_READ_FWD(nodeJson, NodeID, id);                               \
+        JSON_DEF_READ_FWD(nodeJson, GNodeK, nodeKind);                         \
+        return std::make_pair(id, create##GType##Node(id, nodeKind));          \
+    }
+#define READ_CREATE_EDGE_FWD(GType)                                            \
+    [](const cJSON*& edgeJson) {                                               \
+        JSON_DEF_READ_FWD(edgeJson, GEdgeFlag, edgeFlag);                      \
+        auto kind = applyEdgeMask(edgeFlag);                                   \
+        auto edge = create##GType##Edge(kind);                                 \
+        setEdgeFlag(edge, edgeFlag);                                           \
+        return edge;                                                           \
+    }
+
+    ABORT_IFNOT(jsonIsObject(root), "Root should be an object");
+
+    const cJSON* const svfModule = root->child;
+    CHECK_JSON_KEY(svfModule);
+    svfModuleReader.createObjs(
+        svfModule,
+        // SVFType Creator
+        [](const cJSON*& svfTypeFldJson)
+    {
+        JSON_DEF_READ_FWD(svfTypeFldJson, SVFType::GNodeK, kind);
+        JSON_DEF_READ_FWD(svfTypeFldJson, bool, isSingleValTy);
+        return createSVFType(kind, isSingleValTy);
+    },
+    // SVFType Filler
+    [this](const cJSON*& svfVarFldJson, SVFType* type)
+    {
+        virtFill(svfVarFldJson, type);
+    },
+    // SVFValue Creator
+    [this](const cJSON*& svfValueFldJson)
+    {
+        JSON_DEF_READ_FWD(svfValueFldJson, SVFValue::GNodeK, kind);
+        JSON_DEF_READ_FWD(svfValueFldJson, const SVFType*, type, {});
+        JSON_DEF_READ_FWD(svfValueFldJson, std::string, name);
+        return createSVFValue(kind, type, name);
+    },
+    // SVFValue Filler
+    [this](const cJSON*& svfVarFldJson, SVFValue* value)
+    {
+        virtFill(svfVarFldJson, value);
+    },
+    // StInfo Creator (no filler needed)
+    [this](const cJSON*& stInfoFldJson)
+    {
+        JSON_DEF_READ_FWD(stInfoFldJson, u32_t, stride);
+        auto si = new StInfo(stride);
+        fill(stInfoFldJson, si);
+        ABORT_IFNOT(!stInfoFldJson, "StInfo has extra field");
+        return si;
+    });
+
+    const cJSON* const symInfo = svfModule->next;
+    CHECK_JSON_KEY(symInfo);
+    symTableReader.createObjs(
+        symInfo,
+        // MemObj Creator (no filler needed)
+        [this](const cJSON*& memObjFldJson)
+    {
+        JSON_DEF_READ_FWD(memObjFldJson, SymID, symId);
+        JSON_DEF_READ_FWD(memObjFldJson, ObjTypeInfo*, typeInfo, {});
+        JSON_DEF_READ_FWD(memObjFldJson, const SVFValue*, refVal, {});
+        return std::make_pair(symId, new MemObj(symId, typeInfo, refVal));
+    });
+
+    const cJSON* const icfg = symInfo->next;
+    CHECK_JSON_KEY(icfg);
+    icfgReader.createObjs(icfg, READ_CREATE_NODE_FWD(ICFG),
+                          READ_CREATE_EDGE_FWD(ICFG),
+                          [](auto)
+    {
+        return new SVFLoop({}, 0);
+    });
+
+    const cJSON* const chgraph = icfg->next;
+    CHECK_JSON_KEY(chgraph);
+    chGraphReader.createObjs(chgraph, READ_CREATE_NODE_FWD(CH),
+                             READ_CREATE_EDGE_FWD(CH));
+
+    const cJSON* const irGraph = chgraph->next;
+    CHECK_JSON_KEY(irGraph);
+    irGraphReader.createObjs(irGraph, READ_CREATE_NODE_FWD(PAG),
+                             READ_CREATE_EDGE_FWD(PAG));
+
+    icfgReader.fillObjs(
+        [this](const cJSON*& j, ICFGNode* node)
+    {
+        virtFill(j, node);
+    },
+    [this](const cJSON*& j, ICFGEdge* edge)
+    {
+        virtFill(j, edge);
+    },
+    [this](const cJSON*& j, SVFLoop* loop)
+    {
+        fill(j, loop);
+    });
+    chGraphReader.fillObjs(
+        [this](const cJSON*& j, CHNode* node)
+    {
+        virtFill(j, node);
+    },
+    [this](const cJSON*& j, CHEdge* edge)
+    {
+        virtFill(j, edge);
+    });
+    irGraphReader.fillObjs(
+        [this](const cJSON*& j, SVFVar* var)
+    {
+        virtFill(j, var);
+    },
+    [this](const cJSON*& j, SVFStmt* stmt)
+    {
+        virtFill(j, stmt);
+    });
+
+    return irGraph->next;
+
+#undef READ_CREATE_EDGE_FWD
+#undef READ_CREATE_NODE_FWD
+}
+
+void SVFIRReader::readJson(const cJSON* obj, bool& flag)
+{
+    ABORT_IFNOT(jsonIsBool(obj, flag), "Expect bool for " << obj->string);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, unsigned& val)
+{
+    readSmallNumber(obj, val);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, int& val)
+{
+    readSmallNumber(obj, val);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, float& val)
+{
+    readSmallNumber(obj, val);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, unsigned long& val)
+{
+    readBigNumber(obj, val,
+                  [](const char* s)
+    {
+        return std::strtoul(s, nullptr, 10);
+    });
+}
+
+void SVFIRReader::readJson(const cJSON* obj, long long& val)
+{
+    readBigNumber(obj, val,
+                  [](const char* s)
+    {
+        return std::strtoll(s, nullptr, 10);
+    });
+}
+
+void SVFIRReader::readJson(const cJSON* obj, unsigned long long& val)
+{
+    readBigNumber(obj, val,
+                  [](const char* s)
+    {
+        return std::strtoull(s, nullptr, 10);
+    });
+}
+
+void SVFIRReader::readJson(const cJSON* obj, std::string& str)
+{
+    ABORT_IFNOT(jsonIsString(obj), "Expect string for " << obj->string);
+    str = obj->valuestring;
+}
+
+ICFGNode* SVFIRReader::createICFGNode(NodeID id, GNodeK kind)
+{
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible ICFGNodeKind in create()");
+#define CASE(kind, constructor)                                                \
+    case ICFGNode::kind:                                                       \
+        return new constructor(id);
+        CASE(IntraBlock, IntraICFGNode);
+        CASE(FunEntryBlock, FunEntryICFGNode);
+        CASE(FunExitBlock, FunExitICFGNode);
+        CASE(FunCallBlock, CallICFGNode);
+        CASE(FunRetBlock, RetICFGNode);
+        CASE(GlobalBlock, GlobalICFGNode);
+#undef CASE
+    }
+}
+
+ICFGEdge* SVFIRReader::createICFGEdge(GEdgeKind kind)
+{
+    constexpr ICFGNode* src = nullptr;
+    constexpr ICFGNode* dst = nullptr;
+
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible ICFGEdgeKind in create()");
+    case ICFGEdge::IntraCF:
+        return new IntraCFGEdge(src, dst);
+    case ICFGEdge::CallCF:
+        return new CallCFGEdge(src, dst, nullptr);
+    case ICFGEdge::RetCF:
+        return new RetCFGEdge(src, dst, nullptr);
+    }
+}
+
+CHNode* SVFIRReader::createCHNode(NodeID id, GNodeK kind)
+{
+    ABORT_IFNOT(kind == 0, "Impossible CHNode kind " << kind);
+    return new CHNode("", id);
+}
+
+CHEdge* SVFIRReader::createCHEdge(GEdgeKind kind)
+{
+    ABORT_IFNOT(kind == 0, "Unsupported CHEdge kind " << kind);
+    return new CHEdge(nullptr, nullptr, {});
+}
+
+SVFVar* SVFIRReader::createPAGNode(NodeID id, GNodeK kind)
+{
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible SVFVarKind in create()");
+#define CASE(kind, constructor)                                                \
+    case SVFVar::kind:                                                         \
+        return new constructor(id);
+        CASE(ValNode, ValVar);
+        CASE(RetNode, RetPN);
+        CASE(ObjNode, ObjVar);
+        CASE(VarargNode, VarArgPN);
+        CASE(GepValNode, GepValVar);
+        CASE(GepObjNode, GepObjVar);
+        CASE(FIObjNode, FIObjVar);
+        CASE(DummyValNode, DummyValVar);
+        CASE(DummyObjNode, DummyObjVar);
+#undef CASE
+    }
+}
+
+SVFStmt* SVFIRReader::createPAGEdge(GEdgeKind kind)
+{
+    switch (kind)
+    {
+    default:
+        ABORT_MSG(kind << " is an impossible SVFStmtKind in create()");
+#define CASE(kind, constructor)                                                \
+    case SVFStmt::kind:                                                        \
+        return new constructor;
+        CASE(Addr, AddrStmt);
+        CASE(Copy, CopyStmt);
+        CASE(Store, StoreStmt);
+        CASE(Load, LoadStmt);
+        CASE(Call, CallPE);
+        CASE(Ret, RetPE);
+        CASE(Gep, GepStmt);
+        CASE(Phi, PhiStmt);
+        CASE(Select, SelectStmt);
+        CASE(Cmp, CmpStmt);
+        CASE(BinaryOp, BinaryOPStmt);
+        CASE(UnaryOp, UnaryOPStmt);
+        CASE(Branch, BranchStmt);
+        CASE(ThreadFork, TDForkPE);
+        CASE(ThreadJoin, TDJoinPE);
+#undef CASE
+    }
+}
+
+void SVFIRReader::readJson(SymbolTableInfo*& symTabInfo)
+{
+    const cJSON* obj = symTableReader.getFieldJson();
+#define F(field) JSON_READ_FIELD_FWD(obj, symTabInfo, field)
+    // `allMemObj` was consumed during create & fill phase.
+    F(valSymMap);
+    F(objSymMap);
+    F(returnSymMap);
+    F(varargSymMap);
+    symTableReader.memObjMap.saveToIDToObjMap(symTabInfo->objMap); // objMap
+    F(modelConstants);
+    F(totalSymNum);
+    F(maxStruct);
+    F(maxStSize);
+#undef F
+    ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in SymbolTableInfo");
+}
+
+void SVFIRReader::readJson(IRGraph*& graph)
+{
+    assert(SymbolTableInfo::symInfo && "SymbolTableInfo should be nonempty");
+    assert(graph->symInfo == SymbolTableInfo::SymbolInfo() && "symInfo differ");
+
+    auto& valToEdgeMap = graph->valueToEdgeMap;
+    valToEdgeMap.clear();
+
+    irGraphReader.saveToGenericGraph(graph);
+    const cJSON* obj = irGraphReader.getFieldJson();
+#define F(field) JSON_READ_FIELD_FWD(obj, graph, field)
+    // base and symInfo have already been read
+    F(KindToSVFStmtSetMap);
+    F(KindToPTASVFStmtSetMap);
+    F(fromFile);
+    F(nodeNumAfterPAGBuild);
+    F(totalPTAPAGEdge);
+    F(valueToEdgeMap);
+#undef F
+
+    auto nullit = valToEdgeMap.find(nullptr);
+    ABORT_IFNOT(nullit != valToEdgeMap.end(), "valueToEdgeMap should has key NULL");
+    ABORT_IFNOT(nullit->second.empty(), "valueToEdgeMap[NULL] should be empty");
+}
+
+void SVFIRReader::readJson(ICFG*& icfg)
+{
+    icfgReader.saveToGenericGraph(icfg);
+    const cJSON* obj = icfgReader.getFieldJson();
+#define F(field) JSON_READ_FIELD_FWD(obj, icfg, field)
+    F(totalICFGNode);
+    F(FunToFunEntryNodeMap);
+    F(FunToFunExitNodeMap);
+    F(CSToCallNodeMap);
+    F(CSToRetNodeMap);
+    F(InstToBlockNodeMap);
+    F(globalBlockNode);
+    F(icfgNodeToSVFLoopVec);
+#undef F
+}
+
+void SVFIRReader::readJson(CHGraph*& graph)
+{
+    chGraphReader.saveToGenericGraph(graph);
+    const cJSON* obj = chGraphReader.getFieldJson();
+#define F(field) JSON_READ_FIELD_FWD(obj, graph, field)
+    F(classNum);
+    F(vfID);
+    F(classNameToNodeMap);
+    F(classNameToDescendantsMap);
+    F(classNameToAncestorsMap);
+    F(classNameToInstAndDescsMap);
+    F(templateNameToInstancesMap);
+    F(csToClassesMap);
+    F(virtualFunctionToIDMap);
+    F(csToCHAVtblsMap);
+    F(csToCHAVFnsMap);
+#undef F
+}
+
+void SVFIRReader::readJson(SVFModule*& module)
+{
+    const cJSON* obj = svfModuleReader.getFieldJson();
+#define F(field) JSON_READ_FIELD_FWD(obj, module, field)
+    F(pagReadFromTxt);
+    F(moduleIdentifier);
+    F(FunctionSet);
+    F(GlobalSet);
+    F(AliasSet);
+    F(ConstantSet);
+    F(OtherValueSet);
+#undef F
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFType*& type)
+{
+    assert(!type && "SVFType already read?");
+    type = svfModuleReader.getSVFTypePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, StInfo*& stInfo)
+{
+    assert(!stInfo && "StInfo already read?");
+    stInfo = svfModuleReader.getStInfoPtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFValue*& value)
+{
+    assert(!value && "SVFValue already read?");
+    value = svfModuleReader.getSVFValuePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFVar*& var)
+{
+    assert(!var && "SVFVar already read?");
+    if (jsonIsNullId(obj))
+        var = nullptr;
+    else
+        var = irGraphReader.getNodePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFStmt*& stmt)
+{
+    assert(!stmt && "SVFStmt already read?");
+    stmt = irGraphReader.getEdgePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, ICFGNode*& node)
+{
+    assert(!node && "ICFGNode already read?");
+    NodeID id = jsonGetNumber(obj);
+    node = icfgReader.getNodePtr(id);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, ICFGEdge*& edge)
+{
+    assert(!edge && "ICFGEdge already read?");
+    edge = icfgReader.getEdgePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, CHNode*& node)
+{
+    assert(!node && "CHNode already read?");
+    node = chGraphReader.getNodePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, CHEdge*& edge)
+{
+    assert(!edge && "CHEdge already read?");
+    edge = chGraphReader.getEdgePtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, CallSite& cs)
+{
+    readJson(obj, cs.CB);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, LocationSet& ls)
+{
+    ABORT_IFNOT(jsonIsObject(obj), "Expected obj for LocationSet");
+    obj = obj->child;
+    JSON_READ_FIELD_FWD(obj, &ls, fldIdx);
+    JSON_READ_FIELD_FWD(obj, &ls, offsetVarAndGepTypePairs);
+    ABORT_IFNOT(!obj, "Extra field " << JSON_KEY(obj) << " in LocationSet");
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFLoop*& loop)
+{
+    assert(!loop && "SVFLoop already read?");
+    unsigned id = jsonGetNumber(obj);
+    loop = icfgReader.getSVFLoopPtr(id);
+}
+
+void SVFIRReader::readJson(const cJSON* obj, MemObj*& memObj)
+{
+    assert(!memObj && "MemObj already read?");
+    memObj = symTableReader.getMemObjPtr(jsonGetNumber(obj));
+}
+
+void SVFIRReader::readJson(const cJSON* obj, ObjTypeInfo*& objTypeInfo)
+{
+    assert(!objTypeInfo && "ObjTypeInfo already read?");
+    ABORT_IFNOT(jsonIsObject(obj), "Expected object for objTypeInfo");
+    cJSON* field = obj->child;
+
+    JSON_DEF_READ_FWD(field, SVFType*, type, {});
+    JSON_DEF_READ_FWD(field, u32_t, flags);
+    JSON_DEF_READ_FWD(field, u32_t, maxOffsetLimit);
+    JSON_DEF_READ_FWD(field, u32_t, elemNum);
+
+    ABORT_IFNOT(!field, "Extra field in objTypeInfo: " << JSON_KEY(field));
+    objTypeInfo = new ObjTypeInfo(type, maxOffsetLimit);
+    objTypeInfo->flags = flags;
+    objTypeInfo->elemNum = elemNum;
+}
+
+void SVFIRReader::readJson(const cJSON* obj, SVFLoopAndDomInfo*& ldInfo)
+{
+    assert(!ldInfo && "SVFLoopAndDomInfo already read?");
+    ABORT_IFNOT(jsonIsObject(obj), "Expected object for SVFLoopAndDomInfo");
+    cJSON* field = obj->child;
+
+    ldInfo = new SVFLoopAndDomInfo();
+
+    JSON_READ_FIELD_FWD(field, ldInfo, reachableBBs);
+    JSON_READ_FIELD_FWD(field, ldInfo, dtBBsMap);
+    JSON_READ_FIELD_FWD(field, ldInfo, pdtBBsMap);
+    JSON_READ_FIELD_FWD(field, ldInfo, dfBBsMap);
+    JSON_READ_FIELD_FWD(field, ldInfo, bb2LoopMap);
+
+    ABORT_IFNOT(!field,
+                "Extra field in SVFLoopAndDomInfo: " << JSON_KEY(field));
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, SVFVar* var)
+{
+    switch (var->getNodeKind())
+    {
+    default:
+        assert(false && "Unknown SVFVar kind");
+
+#define CASE(VarKind, VarType)                                                 \
+    case SVFVar::VarKind:                                                      \
+        return fill(fieldJson, static_cast<VarType*>(var))
+
+        CASE(ValNode, ValVar);
+        CASE(ObjNode, ObjVar);
+        CASE(RetNode, RetPN);
+        CASE(VarargNode, VarArgPN);
+        CASE(GepValNode, GepValVar);
+        CASE(GepObjNode, GepObjVar);
+        CASE(FIObjNode, FIObjVar);
+        CASE(DummyValNode, DummyValVar);
+        CASE(DummyObjNode, DummyObjVar);
+#undef CASE
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFVar* var)
+{
+    fill(fieldJson, static_cast<GenericPAGNodeTy*>(var));
+    JSON_READ_FIELD_FWD(fieldJson, var, value);
+    JSON_READ_FIELD_FWD(fieldJson, var, InEdgeKindToSetMap);
+    JSON_READ_FIELD_FWD(fieldJson, var, OutEdgeKindToSetMap);
+    JSON_READ_FIELD_FWD(fieldJson, var, isPtr);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, ValVar* var)
+{
+    fill(fieldJson, static_cast<SVFVar*>(var));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, ObjVar* var)
+{
+    fill(fieldJson, static_cast<SVFVar*>(var));
+    JSON_READ_FIELD_FWD(fieldJson, var, mem);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, GepValVar* var)
+{
+    fill(fieldJson, static_cast<ValVar*>(var));
+    JSON_READ_FIELD_FWD(fieldJson, var, ls);
+    JSON_READ_FIELD_FWD(fieldJson, var, gepValType);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, GepObjVar* var)
+{
+    fill(fieldJson, static_cast<ObjVar*>(var));
+    JSON_READ_FIELD_FWD(fieldJson, var, ls);
+    JSON_READ_FIELD_FWD(fieldJson, var, base);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, FIObjVar* var)
+{
+    fill(fieldJson, static_cast<ObjVar*>(var));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, RetPN* var)
+{
+    fill(fieldJson, static_cast<ValVar*>(var));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, VarArgPN* var)
+{
+    fill(fieldJson, static_cast<ValVar*>(var));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, DummyValVar* var)
+{
+    fill(fieldJson, static_cast<ValVar*>(var));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, DummyObjVar* var)
+{
+    fill(fieldJson, static_cast<ObjVar*>(var));
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, SVFStmt* stmt)
+{
+    auto kind = stmt->getEdgeKind();
+
+    switch (kind)
+    {
+    default:
+        ABORT_MSG("Unknown SVFStmt kind " << kind);
+
+#define CASE(EdgeKind, EdgeType)                                               \
+    case SVFStmt::EdgeKind:                                                    \
+        return fill(fieldJson, static_cast<EdgeType*>(stmt))
+
+        CASE(Addr, AddrStmt);
+        CASE(Copy, CopyStmt);
+        CASE(Store, StoreStmt);
+        CASE(Load, LoadStmt);
+        CASE(Call, CallPE);
+        CASE(Ret, RetPE);
+        CASE(Gep, GepStmt);
+        CASE(Phi, PhiStmt);
+        CASE(Select, SelectStmt);
+        CASE(Cmp, CmpStmt);
+        CASE(BinaryOp, BinaryOPStmt);
+        CASE(UnaryOp, UnaryOPStmt);
+        CASE(Branch, BranchStmt);
+        CASE(ThreadFork, TDForkPE);
+        CASE(ThreadJoin, TDJoinPE);
+#undef CASE
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFStmt* stmt)
+{
+    fill(fieldJson, static_cast<GenericPAGEdgeTy*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, value);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, basicBlock);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, icfgNode);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, edgeId);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, AssignStmt* stmt)
+{
+    fill(fieldJson, static_cast<SVFStmt*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, AddrStmt* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, CopyStmt* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, StoreStmt* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, LoadStmt* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, GepStmt* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, ls);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, variantField);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, CallPE* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, call);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, entry);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, RetPE* stmt)
+{
+    fill(fieldJson, static_cast<AssignStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, call);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, exit);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, MultiOpndStmt* stmt)
+{
+    fill(fieldJson, static_cast<SVFStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, opVars);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, PhiStmt* stmt)
+{
+    fill(fieldJson, static_cast<MultiOpndStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, opICFGNodes);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SelectStmt* stmt)
+{
+    fill(fieldJson, static_cast<MultiOpndStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, condition);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, CmpStmt* stmt)
+{
+    fill(fieldJson, static_cast<MultiOpndStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, predicate);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, BinaryOPStmt* stmt)
+{
+    fill(fieldJson, static_cast<MultiOpndStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, opcode);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, UnaryOPStmt* stmt)
+{
+    fill(fieldJson, static_cast<SVFStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, opcode);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, BranchStmt* stmt)
+{
+    fill(fieldJson, static_cast<SVFStmt*>(stmt));
+    JSON_READ_FIELD_FWD(fieldJson, stmt, successors);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, cond);
+    JSON_READ_FIELD_FWD(fieldJson, stmt, brInst);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, TDForkPE* stmt)
+{
+    fill(fieldJson, static_cast<CallPE*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, TDJoinPE* stmt)
+{
+    fill(fieldJson, static_cast<RetPE*>(stmt));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, MemObj* memObj)
+{
+    // symId has already been read
+    JSON_READ_FIELD_FWD(fieldJson, memObj, typeInfo);
+    JSON_READ_FIELD_FWD(fieldJson, memObj, refVal);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, StInfo* stInfo)
+{
+#define F(field) JSON_READ_FIELD_FWD(fieldJson, stInfo, field)
+    // stride has already been read
+    F(fldIdxVec);
+    F(elemIdxVec);
+    F(fldIdx2TypeMap);
+    F(finfo);
+    F(numOfFlattenElements);
+    F(flattenElementTypes);
+#undef F
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, ICFGNode* node)
+{
+    switch (node->getNodeKind())
+    {
+    default:
+        ABORT_MSG("Unknown ICFGNode kind " << node->getNodeKind());
+
+#define CASE(NodeKind, NodeType)                                               \
+    case ICFGNode::NodeKind:                                                   \
+        return fill(fieldJson, static_cast<NodeType*>(node))
+
+        CASE(IntraBlock, IntraICFGNode);
+        CASE(FunEntryBlock, FunEntryICFGNode);
+        CASE(FunExitBlock, FunExitICFGNode);
+        CASE(FunCallBlock, CallICFGNode);
+        CASE(FunRetBlock, RetICFGNode);
+        CASE(GlobalBlock, GlobalICFGNode);
+#undef CASE
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, ICFGNode* node)
+{
+    fill(fieldJson, static_cast<GenericICFGNodeTy*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, fun);
+    JSON_READ_FIELD_FWD(fieldJson, node, bb);
+    // Skip VFGNodes as it is empty
+    JSON_READ_FIELD_FWD(fieldJson, node, pagEdges);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, GlobalICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, IntraICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, inst);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, InterICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, FunEntryICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, FPNodes);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, FunExitICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, formalRet);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, CallICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, cs);
+    JSON_READ_FIELD_FWD(fieldJson, node, ret);
+    JSON_READ_FIELD_FWD(fieldJson, node, APNodes);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, RetICFGNode* node)
+{
+    fill(fieldJson, static_cast<ICFGNode*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, cs);
+    JSON_READ_FIELD_FWD(fieldJson, node, actualRet);
+    JSON_READ_FIELD_FWD(fieldJson, node, callBlockNode);
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, ICFGEdge* edge)
+{
+    auto kind = edge->getEdgeKind();
+    switch (kind)
+    {
+    default:
+        ABORT_MSG("Unknown ICFGEdge kind " << kind);
+    case ICFGEdge::IntraCF:
+        return fill(fieldJson, static_cast<IntraCFGEdge*>(edge));
+    case ICFGEdge::CallCF:
+        return fill(fieldJson, static_cast<CallCFGEdge*>(edge));
+    case ICFGEdge::RetCF:
+        return fill(fieldJson, static_cast<RetCFGEdge*>(edge));
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, ICFGEdge* edge)
+{
+    fill(fieldJson, static_cast<GenericICFGEdgeTy*>(edge));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, IntraCFGEdge* edge)
+{
+    fill(fieldJson, static_cast<ICFGEdge*>(edge));
+    JSON_READ_FIELD_FWD(fieldJson, edge, conditionVar);
+    JSON_READ_FIELD_FWD(fieldJson, edge, branchCondVal);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, CallCFGEdge* edge)
+{
+    fill(fieldJson, static_cast<ICFGEdge*>(edge));
+    JSON_READ_FIELD_FWD(fieldJson, edge, cs);
+    JSON_READ_FIELD_FWD(fieldJson, edge, callPEs);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, RetCFGEdge* edge)
+{
+    fill(fieldJson, static_cast<ICFGEdge*>(edge));
+    JSON_READ_FIELD_FWD(fieldJson, edge, cs);
+    JSON_READ_FIELD_FWD(fieldJson, edge, retPE);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFLoop* loop)
+{
+#define F(field) JSON_READ_FIELD_FWD(fieldJson, loop, field)
+    F(entryICFGEdges);
+    F(backICFGEdges);
+    F(inICFGEdges);
+    F(outICFGEdges);
+    F(icfgNodes);
+    F(loopBound);
+#undef F
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, CHNode* node)
+{
+    assert(node->getNodeKind() == 0 && "Unknown CHNode kind");
+    fill(fieldJson, static_cast<GenericCHNodeTy*>(node));
+    JSON_READ_FIELD_FWD(fieldJson, node, vtable);
+    JSON_READ_FIELD_FWD(fieldJson, node, className);
+    JSON_READ_FIELD_FWD(fieldJson, node, flags);
+    JSON_READ_FIELD_FWD(fieldJson, node, virtualFunctionVectors);
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, CHEdge* edge)
+{
+    assert(edge->getEdgeKind() == 0 && "Unknown CHEdge kind");
+    fill(fieldJson, static_cast<GenericCHEdgeTy*>(edge));
+    // edgeType is a enum
+    JSON_DEF_READ_FWD(fieldJson, unsigned, edgeType);
+    if (edgeType == CHEdge::INHERITANCE)
+        edge->edgeType = CHEdge::INHERITANCE;
+    else if (edgeType == CHEdge::INSTANTCE)
+        edge->edgeType = CHEdge::INSTANTCE;
+    else
+        ABORT_MSG("Unknown CHEdge type " << edgeType);
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, SVFValue* value)
+{
+    auto kind = value->getKind();
+
+    switch (kind)
+    {
+    default:
+        ABORT_MSG("Impossible SVFValue kind " << kind);
+
+#define CASE(ValueKind, Type)                                                  \
+    case SVFValue::ValueKind:                                                  \
+        return fill(fieldJson, static_cast<Type*>(value))
+
+        CASE(SVFVal, SVFValue);
+        CASE(SVFFunc, SVFFunction);
+        CASE(SVFBB, SVFBasicBlock);
+        CASE(SVFInst, SVFInstruction);
+        CASE(SVFCall, SVFCallInst);
+        CASE(SVFVCall, SVFVirtualCallInst);
+        CASE(SVFGlob, SVFGlobalValue);
+        CASE(SVFArg, SVFArgument);
+        CASE(SVFConst, SVFConstant);
+        CASE(SVFConstData, SVFConstantData);
+        CASE(SVFConstInt, SVFConstantInt);
+        CASE(SVFConstFP, SVFConstantFP);
+        CASE(SVFNullPtr, SVFConstantNullPtr);
+        CASE(SVFBlackHole, SVFBlackHoleValue);
+        CASE(SVFMetaAsValue, SVFMetadataAsValue);
+        CASE(SVFOther, SVFOtherValue);
+#undef CASE
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFValue* value)
+{
+    // kind, type, name have already been read.
+    JSON_READ_FIELD_FWD(fieldJson, value, ptrInUncalledFun);
+    JSON_READ_FIELD_FWD(fieldJson, value, constDataOrAggData);
+    JSON_READ_FIELD_FWD(fieldJson, value, sourceLoc);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFFunction* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+#define F(f) JSON_READ_FIELD_FWD(fieldJson, value, f)
+    F(isDecl);
+    F(intrinsic);
+    F(addrTaken);
+    F(isUncalled);
+    F(isNotRet);
+    F(varArg);
+    F(funcType);
+    F(loopAndDom);
+    F(realDefFun);
+    F(allBBs);
+    F(allArgs);
+#undef F
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFBasicBlock* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, allInsts);
+    JSON_READ_FIELD_FWD(fieldJson, value, succBBs);
+    JSON_READ_FIELD_FWD(fieldJson, value, predBBs);
+    JSON_READ_FIELD_FWD(fieldJson, value, fun);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFInstruction* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, bb);
+    JSON_READ_FIELD_FWD(fieldJson, value, terminator);
+    JSON_READ_FIELD_FWD(fieldJson, value, ret);
+    JSON_READ_FIELD_FWD(fieldJson, value, succInsts);
+    JSON_READ_FIELD_FWD(fieldJson, value, predInsts);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFCallInst* value)
+{
+    fill(fieldJson, static_cast<SVFInstruction*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, args);
+    JSON_READ_FIELD_FWD(fieldJson, value, varArg);
+    JSON_READ_FIELD_FWD(fieldJson, value, calledVal);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFVirtualCallInst* value)
+{
+    fill(fieldJson, static_cast<SVFCallInst*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, vCallVtblPtr);
+    JSON_READ_FIELD_FWD(fieldJson, value, virtualFunIdx);
+    JSON_READ_FIELD_FWD(fieldJson, value, funNameOfVcall);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFConstant* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFGlobalValue* value)
+{
+    fill(fieldJson, static_cast<SVFConstant*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, realDefGlobal);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFArgument* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, fun);
+    JSON_READ_FIELD_FWD(fieldJson, value, argNo);
+    JSON_READ_FIELD_FWD(fieldJson, value, uncalled);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFConstantData* value)
+{
+    fill(fieldJson, static_cast<SVFConstant*>(value));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFConstantInt* value)
+{
+    fill(fieldJson, static_cast<SVFConstantData*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, zval);
+    JSON_READ_FIELD_FWD(fieldJson, value, sval);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFConstantFP* value)
+{
+    fill(fieldJson, static_cast<SVFConstantData*>(value));
+    JSON_READ_FIELD_FWD(fieldJson, value, dval);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFConstantNullPtr* value)
+{
+    fill(fieldJson, static_cast<SVFConstantData*>(value));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFBlackHoleValue* value)
+{
+    fill(fieldJson, static_cast<SVFConstantData*>(value));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFOtherValue* value)
+{
+    fill(fieldJson, static_cast<SVFValue*>(value));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFMetadataAsValue* value)
+{
+    fill(fieldJson, static_cast<SVFOtherValue*>(value));
+}
+
+void SVFIRReader::virtFill(const cJSON*& fieldJson, SVFType* type)
+{
+    auto kind = type->getKind();
+
+    switch (kind)
+    {
+    default:
+        assert(false && "Impossible SVFType kind");
+
+#define CASE(Kind)                                                             \
+    case SVFType::Kind:                                                        \
+        return fill(fieldJson, SVFUtil::dyn_cast<Kind##pe>(type))
+
+        CASE(SVFTy);
+        CASE(SVFPointerTy);
+        CASE(SVFIntegerTy);
+        CASE(SVFFunctionTy);
+        CASE(SVFStructTy);
+        CASE(SVFArrayTy);
+        CASE(SVFOtherTy);
+#undef CASE
+    }
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFType* type)
+{
+    // kind has already been read
+    JSON_READ_FIELD_FWD(fieldJson, type, getPointerToTy);
+    JSON_READ_FIELD_FWD(fieldJson, type, typeinfo);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFPointerType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+    JSON_READ_FIELD_FWD(fieldJson, type, ptrElementType);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFIntegerType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFFunctionType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+    JSON_READ_FIELD_FWD(fieldJson, type, retTy);
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFStructType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFArrayType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+}
+
+void SVFIRReader::fill(const cJSON*& fieldJson, SVFOtherType* type)
+{
+    fill(fieldJson, static_cast<SVFType*>(type));
+}
+
+SVFIR* SVFIRReader::read(const std::string& path)
+{
+    struct stat buf;
+    int fd = open(path.c_str(), O_RDONLY);
+    if (fd == -1)
+    {
+        std::string info = "open(\"" + path + "\")";
+        perror(info.c_str());
+        abort();
+    }
+    if (fstat(fd, &buf) == -1)
+    {
+        std::string info = "fstate(\"" + path + "\")";
+        perror(info.c_str());
+        abort();
+    }
+    auto addr =
+        (char*)mmap(nullptr, buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+    if (addr == MAP_FAILED)
+    {
+        std::string info = "mmap(content of \"" + path + "\")";
+        perror(info.c_str());
+        abort();
+    }
+
+    auto root = cJSON_ParseWithLength(addr, buf.st_size);
+
+    if (munmap(addr, buf.st_size) == -1)
+        perror("munmap()");
+
+    if (close(fd) < 0)
+        perror("close()");
+
+    SVFIRReader reader;
+    SVFIR* ir = reader.read(root);
+
+    cJSON_Delete(root);
+    return ir;
+}
+
+} // namespace SVF