svf-tools 1.0.693 → 1.0.695

package/svf/include/SVFIR/SVFIRRW.h

@@ -1,18 +1,56 @@
+//===- SVFIRRW.h -- SVF IR Reader and Writer ------------------------------===//
+//
+//  SVF - Static Value-Flow Analysis Framework
+//                     SVF: Static Value-Flow Analysis
+//
+// Copyright (C) <2013-2023>  <Yulei Sui>
+//
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+//===----------------------------------------------------------------------===//
+
 #ifndef INCLUDE_SVFIRRW_H_
 #define INCLUDE_SVFIRRW_H_
 
+#include "Graphs/GenericGraph.h"
 #include "Util/SVFUtil.h"
 #include "Util/cJSON.h"
-#include "Graphs/GenericGraph.h"
 #include <type_traits>
 
-#if 1
+#define ABORT_MSG(reason)                                                      \
+    do                                                                         \
+    {                                                                          \
+        SVFUtil::errs() << __FILE__ << ':' << __LINE__ << ": " << reason       \
+                        << '\n';                                               \
+        abort();                                                               \
+    } while (0)
+#define ABORT_IFNOT(condition, reason)                                         \
+    do                                                                         \
+    {                                                                          \
+        if (!(condition))                                                      \
+            ABORT_MSG(reason);                                                 \
+    } while (0)
+
+#define SVFIR_DEBUG 1 /* Turn this on if you're debugging SVFWriter */
+#if SVFIR_DEBUG
 #    define ENSURE_NOT_VISITED(graph)                                          \
         do                                                                     \
         {                                                                      \
             static std::set<decltype(graph)> visited;                          \
             bool inserted = visited.insert(graph).second;                      \
-            ABORT_IFNOT(!inserted, #graph " already visited!");                \
+            ABORT_IFNOT(inserted, #graph << " already visited!");              \
         } while (0)
 #else
 #    define ENSURE_NOT_VISITED(graph)                                          \
@@ -20,53 +58,48 @@
         {                                                                      \
         } while (0)
 #endif
+#define FIELD_NAME_ITEM(field) #field, (field)
 
-#define ABORT_IFNOT(condition, reason)                                         \
+#define JSON_FIELD_OR(json, field, default) ((json) ? (json)->field : default)
+#define JSON_KEY(json) JSON_FIELD_OR(json, string, "NULL")
+#define JSON_CHILD(json) JSON_FIELD_OR(json, child, nullptr)
+
+#define JSON_WRITE_FIELD(root, objptr, field)                                  \
+    jsonAddJsonableToObject(root, #field, (objptr)->field)
+
+#define JSON_READ_OBJ_WITH_NAME(json, obj, name)                               \
     do                                                                         \
     {                                                                          \
-        if (!(condition))                                                      \
-        {                                                                      \
-            SVFUtil::errs()                                                    \
-                << __FILE__ << ':' << __LINE__ << ": " << reason << '\n';      \
-            abort();                                                           \
-        }                                                                      \
+        ABORT_IFNOT(jsonKeyEquals(json, name),                                 \
+                    "Expect name '" << name << "', got " << JSON_KEY(json));   \
+        SVFIRReader::readJson(json, obj);                                      \
     } while (0)
 
-#define JSON_WRITE_FIELD(root, objptr, field)                                  \
-    jsonAddJsonableToObject(root, #field, (objptr)->field)
+#define JSON_READ_OBJ_WITH_NAME_FWD(json, obj, name)                           \
+    do                                                                         \
+    {                                                                          \
+        JSON_READ_OBJ_WITH_NAME(json, obj, name);                              \
+        json = (json)->next;                                                   \
+    } while (0)
 
-/// @brief Type trait to check if a type is iterable.
-///@{
-template <typename T>
-decltype(std::begin(std::declval<T&>()) !=
-         std::end(std::declval<T&>()), // begin/end and operator!=
-         void(),                           // Handle evil operator,
-         ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator++
-         *begin(std::declval<T&>()),                             // operator*
-         std::true_type {})
-is_iterable_impl(int);
-template <typename T> std::false_type is_iterable_impl(...);
-
-template <typename T>
-using is_iterable = decltype(is_iterable_impl<T>(0));
-template <typename T> constexpr bool is_iterable_v = is_iterable<T>::value;
-///@}
+#define JSON_READ_OBJ(json, obj) JSON_READ_OBJ_WITH_NAME(json, obj, #obj)
+#define JSON_READ_OBJ_FWD(json, obj)                                           \
+    JSON_READ_OBJ_WITH_NAME_FWD(json, obj, #obj)
+#define JSON_DEF_READ_FWD(json, type, obj, ...)                                \
+    type obj __VA_ARGS__;                                                      \
+    JSON_READ_OBJ_FWD(json, obj)
+#define JSON_READ_FIELD_FWD(json, objptr, field)                               \
+    JSON_READ_OBJ_WITH_NAME_FWD(json, (objptr)->field, #field)
+#define CHECK_JSON_KEY_EQUALS(obj, key)                                        \
+    ABORT_IFNOT(jsonKeyEquals(obj, key),                                       \
+                "Expect json key: " << key << ", but get " << JSON_KEY(obj));
+#define CHECK_JSON_KEY(obj) CHECK_JSON_KEY_EQUALS(obj, #obj)
 
 namespace SVF
 {
-class SVFIR;
-class SVFIRWriter;
-class SVFLoop;
-class ICFG;
-class IRGraph;
-class CHGraph;
-class CommonCHGraph;
-class SymbolTableInfo;
-class MemObj;
-
-class SVFModule;
-
-class StInfo;
+/// @brief Forward declarations.
+///@{
+// Classes created upon SVFMoudle construction
 class SVFType;
 class SVFPointerType;
 class SVFIntegerType;
@@ -75,7 +108,8 @@ class SVFStructType;
 class SVFArrayType;
 class SVFOtherType;
 
-class SVFLoopAndDomInfo;
+class StInfo; // Every SVFType is linked to a StInfo. It also references SVFType
+
 class SVFValue;
 class SVFFunction;
 class SVFBasicBlock;
@@ -93,36 +127,12 @@ class SVFBlackHoleValue;
 class SVFOtherValue;
 class SVFMetadataAsValue;
 
-class SVFVar;
-class ValVar;
-class ObjVar;
-class GepValVar;
-class GepObjVar;
-class FIObjVar;
-class RetPN;
-class VarArgPN;
-class DummyValVar;
-class DummyObjVar;
+class SVFLoopAndDomInfo; // Part of SVFFunction
 
-class SVFStmt;
-class AssignStmt;
-class AddrStmt;
-class CopyStmt;
-class StoreStmt;
-class LoadStmt;
-class GepStmt;
-class CallPE;
-class RetPE;
-class MultiOpndStmt;
-class PhiStmt;
-class SelectStmt;
-class CmpStmt;
-class BinaryOPStmt;
-class UnaryOPStmt;
-class BranchStmt;
-class TDForkPE;
-class TDJoinPE;
+// Classes created upon buildSymbolTableInfo
+class MemObj;
 
+// Classes created upon ICFG construction
 class ICFGNode;
 class GlobalICFGNode;
 class IntraICFGNode;
@@ -137,37 +147,19 @@ class IntraCFGEdge;
 class CallCFGEdge;
 class RetCFGEdge;
 
+class SVFIR;
+class SVFIRWriter;
+class SVFLoop;
+class ICFG;
+class IRGraph;
+class CHGraph;
+class CommonCHGraph;
+class SymbolTableInfo;
 
 class SVFModule;
 
-class StInfo;
-class SVFType;
-class SVFPointerType;
-class SVFIntegerType;
-class SVFFunctionType;
-class SVFStructType;
-class SVFArrayType;
-class SVFOtherType;
 class LocationSet;
-class ObjTypeInfo;
-
-class SVFLoopAndDomInfo;
-class SVFValue;
-class SVFFunction;
-class SVFBasicBlock;
-class SVFInstruction;
-class SVFCallInst;
-class SVFVirtualCallInst;
-class SVFConstant;
-class SVFGlobalValue;
-class SVFArgument;
-class SVFConstantData;
-class SVFConstantInt;
-class SVFConstantFP;
-class SVFConstantNullPtr;
-class SVFBlackHoleValue;
-class SVFOtherValue;
-class SVFMetadataAsValue;
+class ObjTypeInfo; // Need SVFType
 
 class SVFVar;
 class ValVar;
@@ -199,31 +191,29 @@ class BranchStmt;
 class TDForkPE;
 class TDJoinPE;
 
-class ICFGNode;
-class GlobalICFGNode;
-class IntraICFGNode;
-class InterICFGNode;
-class FunEntryICFGNode;
-class FunExitICFGNode;
-class CallICFGNode;
-class RetICFGNode;
-
-class ICFGEdge;
-class IntraCFGEdge;
-class CallCFGEdge;
-class RetCFGEdge;
-
 class CHNode;
 class CHEdge;
 class CHGraph;
+// End of forward declarations
+///@}
 
-cJSON* jsonCreateNullId();
+bool jsonIsBool(const cJSON* item);
+bool jsonIsBool(const cJSON* item, bool& flag);
+bool jsonIsNumber(const cJSON* item);
+bool jsonIsString(const cJSON* item);
 bool jsonIsNullId(const cJSON* item);
+bool jsonIsArray(const cJSON* item);
+bool jsonIsMap(const cJSON* item);
+bool jsonIsObject(const cJSON* item);
+bool jsonKeyEquals(const cJSON* item, const char* key);
+std::pair<const cJSON*, const cJSON*> jsonUnpackPair(const cJSON* item);
+double jsonGetNumber(const cJSON* item);
+cJSON* jsonCreateNullId();
 cJSON* jsonCreateObject();
 cJSON* jsonCreateArray();
-cJSON* jsonCreateMap();
 cJSON* jsonCreateString(const char* str);
 cJSON* jsonCreateIndex(size_t index);
+cJSON* jsonCreateBool(bool flag);
 cJSON* jsonCreateNumber(double num);
 bool jsonAddPairToMap(cJSON* obj, cJSON* key, cJSON* value);
 bool jsonAddItemToObject(cJSON* obj, const char* name, cJSON* item);
@@ -231,10 +221,14 @@ bool jsonAddItemToArray(cJSON* array, cJSON* item);
 /// @brief Helper function to write a number to a JSON object.
 bool jsonAddNumberToObject(cJSON* obj, const char* name, double number);
 bool jsonAddStringToObject(cJSON* obj, const char* name, const char* str);
-bool jsonAddStringToObject(cJSON* obj, const char* name,
-                           const std::string& str);
-
-template <typename T> class PtrPool
+bool jsonAddStringToObject(cJSON* obj, const char* name, const std::string& s);
+#define jsonForEach(field, array)                                              \
+    for (const cJSON* field = JSON_CHILD(array); field; field = field->next)
+
+/// @brief Bookkeeping class to keep track of the IDs of objects that doesn't
+/// have any ID. E.g., SVFValue, XXXEdge.
+/// @tparam T
+template <typename T> class WriterPtrPool
 {
 private:
     Map<const T*, size_t> ptrToId;
@@ -243,12 +237,15 @@ private:
 public:
     inline size_t getID(const T* ptr)
     {
-        if (ptr == nullptr)
+        if (!ptr)
             return 0;
-        auto it_inserted = ptrToId.emplace(ptr, 1 + ptrPool.size());
-        if (it_inserted.second)
+
+        typename decltype(ptrToId)::iterator it;
+        bool inserted;
+        std::tie(it, inserted) = ptrToId.emplace(ptr, 1 + ptrPool.size());
+        if (inserted)
             ptrPool.push_back(ptr);
-        return it_inserted.first->second;
+        return it->second;
     }
 
     inline void saveID(const T* ptr)
@@ -258,7 +255,7 @@ public:
 
     inline const T* getPtr(size_t id) const
     {
-        assert(id >= 0 && id <= ptrPool.size() && "Invalid ID.");
+        assert(id <= ptrPool.size() && "Invalid ID");
         return id ? ptrPool[id - 1] : nullptr;
     }
 
@@ -267,10 +264,25 @@ public:
         return ptrPool;
     }
 
-    size_t size() const
+    inline size_t size() const
     {
         return ptrPool.size();
     }
+
+    inline void reserve(size_t size)
+    {
+        ptrPool.reserve(size);
+    }
+
+    inline auto begin() const
+    {
+        return ptrPool.cbegin();
+    }
+
+    inline auto end() const
+    {
+        return ptrPool.cend();
+    }
 };
 
 template <typename NodeTy, typename EdgeTy> class GenericGraphWriter
@@ -282,21 +294,19 @@ private:
     using EdgeType = EdgeTy;
     using GraphType = GenericGraph<NodeType, EdgeType>;
 
-    const GraphType* graph;
-    OrderedMap<const NodeType*, NodeID> nodeToID;
-    PtrPool<EdgeType> edgePool;
+    // const GraphType* graph;
+    WriterPtrPool<EdgeType> edgePool;
 
 public:
-    GenericGraphWriter(const GraphType* g) : graph(g)
+    GenericGraphWriter(const GraphType* graph)
     {
-        assert(g && "Graph pointer should never be null");
+        assert(graph && "Graph pointer should never be null");
+        edgePool.reserve(graph->getTotalEdgeNum());
 
-        for (const auto& entry : graph->IDToNodeMap)
+        for (const auto& pair : graph->IDToNodeMap)
         {
-            const NodeID id = entry.first;
-            const NodeType* node = entry.second;
+            const NodeType* node = pair.second;
 
-            nodeToID.emplace(node, id);
             for (const EdgeType* edge : node->getOutEdges())
             {
                 edgePool.saveID(edge);
@@ -308,13 +318,6 @@ public:
     {
         return edgePool.getID(edge);
     }
-
-    inline NodeID getNodeID(const NodeType* node) const
-    {
-        auto it = nodeToID.find(node);
-        assert(it != nodeToID.end() && "Node not found in the graph.");
-        return it->second;
-    }
 };
 
 using GenericICFGWriter = GenericGraphWriter<ICFGNode, ICFGEdge>;
@@ -324,7 +327,7 @@ class ICFGWriter : public GenericICFGWriter
     friend class SVFIRWriter;
 
 private:
-    PtrPool<SVFLoop> svfLoopPool;
+    WriterPtrPool<SVFLoop> svfLoopPool;
 
 public:
     ICFGWriter(const ICFG* icfg);
@@ -335,18 +338,6 @@ public:
     }
 };
 
-class SymbolTableInfoWriter
-{
-public:
-    SymbolTableInfoWriter(const SymbolTableInfo* symbolTableInfo);
-
-    SymID getMemObjID(const MemObj* memObj);
-
-private:
-    const SymbolTableInfo* symbolTableInfo;
-    OrderedMap<const MemObj*, SymID> memObjToID;
-};
-
 using IRGraphWriter = GenericGraphWriter<SVFVar, SVFStmt>;
 using CHGraphWriter = GenericGraphWriter<CHNode, CHEdge>;
 
@@ -354,11 +345,34 @@ class SVFModuleWriter
 {
     friend class SVFIRWriter;
 
-    PtrPool<SVFType> svfTypePool;
-    PtrPool<SVFValue> svfValuePool;
+private:
+    WriterPtrPool<SVFType> svfTypePool;
+    WriterPtrPool<StInfo> stInfoPool;
+    WriterPtrPool<SVFValue> svfValuePool;
+
+public:
+    SVFModuleWriter(const SVFModule* svfModule);
 
-    size_t getSvfTypeID(const SVFType* type);
-    size_t getSvfValueID(const SVFValue* value);
+    inline size_t getSVFValueID(const SVFValue* value)
+    {
+        return svfValuePool.getID(value);
+    }
+    inline const SVFValue* getSVFValuePtr(size_t id) const
+    {
+        return svfValuePool.getPtr(id);
+    }
+    inline size_t getSVFTypeID(const SVFType* type)
+    {
+        return svfTypePool.getID(type);
+    }
+    inline size_t getStInfoID(const StInfo* stInfo)
+    {
+        return stInfoPool.getID(stInfo);
+    }
+    inline size_t sizeSVFValuePool() const
+    {
+        return svfValuePool.size();
+    }
 };
 
 class SVFIRWriter
@@ -367,10 +381,9 @@ private:
     const SVFIR* svfIR;
 
     SVFModuleWriter svfModuleWriter;
-    IRGraphWriter irGraphWriter;
     ICFGWriter icfgWriter;
     CHGraphWriter chgWriter;
-    SymbolTableInfoWriter symbolTableInfoWriter;
+    IRGraphWriter irGraphWriter;
 
     OrderedMap<size_t, std::string> numToStrMap;
 
@@ -378,6 +391,7 @@ public:
     using autoJSON = std::unique_ptr<cJSON, decltype(&cJSON_Delete)>;
     using autoCStr = std::unique_ptr<char, decltype(&cJSON_free)>;
 
+    /// @brief Constructor.
     SVFIRWriter(const SVFIR* svfir);
 
     static void writeJsonToOstream(const SVFIR* svfir, std::ostream& os);
@@ -390,31 +404,34 @@ private:
 
     const char* numToStr(size_t n);
 
+    cJSON* toJson(const SymbolTableInfo* symTable);
     cJSON* toJson(const SVFModule* module);
     cJSON* toJson(const SVFType* type);
     cJSON* toJson(const SVFValue* value);
-    cJSON* toJson(const IRGraph* graph); // IRGraph Graph
-    cJSON* toJson(const SVFVar* var);    // IRGraph Node
-    cJSON* toJson(const SVFStmt* stmt);  // IRGraph Edge
-    cJSON* toJson(const ICFG* icfg);     // ICFG Graph
-    cJSON* toJson(const ICFGNode* node); // ICFG Node
-    cJSON* toJson(const ICFGEdge* edge); // ICFG Edge
+    cJSON* toJson(const IRGraph* graph);       // IRGraph Graph
+    cJSON* toJson(const SVFVar* var);          // IRGraph Node
+    cJSON* toJson(const SVFStmt* stmt);        // IRGraph Edge
+    cJSON* toJson(const ICFG* icfg);           // ICFG Graph
+    cJSON* toJson(const ICFGNode* node);       // ICFG Node
+    cJSON* toJson(const ICFGEdge* edge);       // ICFG Edge
     cJSON* toJson(const CommonCHGraph* graph); // CHGraph Graph
-    cJSON* toJson(const CHGraph* graph); // CHGraph Graph
-    cJSON* toJson(const CHNode* node);   // CHGraph Node
-    cJSON* toJson(const CHEdge* edge);   // CHGraph Edge
+    cJSON* toJson(const CHGraph* graph);       // CHGraph Graph
+    cJSON* toJson(const CHNode* node);         // CHGraph Node
+    cJSON* toJson(const CHEdge* edge);         // CHGraph Edge
 
     cJSON* toJson(const CallSite& cs);
     cJSON* toJson(const LocationSet& ls);
     cJSON* toJson(const SVFLoop* loop);
     cJSON* toJson(const MemObj* memObj);
-    cJSON* toJson(const ObjTypeInfo* objTypeInfo); // Only owned by MemObj
+    cJSON* toJson(const ObjTypeInfo* objTypeInfo);  // Only owned by MemObj
     cJSON* toJson(const SVFLoopAndDomInfo* ldInfo); // Only owned by SVFFunction
-    cJSON* toJson(const StInfo* type); // Ensure Only owned by SVFType
+    cJSON* toJson(const StInfo* stInfo);
 
+    static cJSON* toJson(bool flag);
     static cJSON* toJson(unsigned number);
     static cJSON* toJson(int number);
     static cJSON* toJson(float number);
+    static cJSON* toJson(const std::string& str);
     cJSON* toJson(unsigned long number);
     cJSON* toJson(long long number);
     cJSON* toJson(unsigned long long number);
@@ -511,8 +528,8 @@ private:
 
     // Other classes
     cJSON* contentToJson(const SVFLoop* loop);
-    cJSON* contentToJson(const SymbolTableInfo* symTable);
     cJSON* contentToJson(const MemObj* memObj); // Owned by SymbolTable->objMap
+    cJSON* contentToJson(const StInfo* stInfo);
     ///@}
 
     template <typename NodeTy, typename EdgeTy>
@@ -530,9 +547,9 @@ private:
     cJSON* genericEdgeToJson(const GenericEdge<NodeTy>* edge)
     {
         cJSON* root = jsonCreateObject();
+        JSON_WRITE_FIELD(root, edge, edgeFlag);
         JSON_WRITE_FIELD(root, edge, src);
         JSON_WRITE_FIELD(root, edge, dst);
-        JSON_WRITE_FIELD(root, edge, edgeFlag);
         return root;
     }
 
@@ -542,33 +559,31 @@ private:
     {
         cJSON* root = jsonCreateObject();
 
-        JSON_WRITE_FIELD(root, graph, edgeNum);
-        JSON_WRITE_FIELD(root, graph, nodeNum);
-
-        cJSON* map = jsonCreateMap();
+        cJSON* allNode = jsonCreateArray();
         for (const auto& pair : graph->IDToNodeMap)
         {
-            NodeID id = pair.first;
             NodeTy* node = pair.second;
-
-            cJSON* jsonID = jsonCreateIndex(id);
             cJSON* jsonNode = virtToJson(node);
-            jsonAddPairToMap(map, jsonID, jsonNode);
+            jsonAddItemToArray(allNode, jsonNode);
         }
 
-        cJSON* edgesJson = jsonCreateArray();
+        cJSON* allEdge = jsonCreateArray();
         for (const EdgeTy* edge : edgePool)
         {
             cJSON* edgeJson = virtToJson(edge);
-            jsonAddItemToArray(edgesJson, edgeJson);
+            jsonAddItemToArray(allEdge, edgeJson);
         }
-        jsonAddItemToObject(root, "edges", edgesJson);
+
+        JSON_WRITE_FIELD(root, graph, nodeNum);
+        jsonAddItemToObject(root, FIELD_NAME_ITEM(allNode));
+        JSON_WRITE_FIELD(root, graph, edgeNum);
+        jsonAddItemToObject(root, FIELD_NAME_ITEM(allEdge));
 
         return root;
     }
 
     template <unsigned ElementSize>
-    cJSON* toJson(const SparseBitVectorElement<ElementSize> &element)
+    cJSON* toJson(const SparseBitVectorElement<ElementSize>& element)
     {
         cJSON* array = jsonCreateArray();
         for (const auto v : element.Bits)
@@ -592,8 +607,9 @@ private:
         return obj;
     }
 
-    template <typename T, typename = std::enable_if_t<is_iterable_v<T>>>
-              cJSON* toJson(const T& container)
+    template <typename T,
+              typename = std::enable_if_t<SVFUtil::is_iterable_v<T>>>
+                                          cJSON* toJson(const T& container)
     {
         cJSON* array = jsonCreateArray();
         for (const auto& item : container)
@@ -619,6 +635,668 @@ private:
     }
 };
 
+/*
+ * Reader Part
+ */
+
+/// @brief Type trait to get base type.
+/// Helper struct to detect inheritance from Node/Edge
+///@}
+template <typename T, typename = void> struct KindBaseHelper
+{
+};
+#define KIND_BASE(B, KindGetter)                                               \
+    template <typename T>                                                      \
+    struct KindBaseHelper<T, std::enable_if_t<std::is_base_of<B, T>::value>>   \
+    {                                                                          \
+        using type = B;                                                        \
+        static inline s64_t getKind(T* p)                                      \
+        {                                                                      \
+            return p->KindGetter();                                            \
+        }                                                                      \
+    }
+KIND_BASE(SVFType, getKind);
+KIND_BASE(SVFValue, getKind);
+KIND_BASE(SVFVar, getNodeKind);
+KIND_BASE(SVFStmt, getEdgeKind);
+KIND_BASE(ICFGNode, getNodeKind);
+KIND_BASE(ICFGEdge, getEdgeKind);
+KIND_BASE(CHNode, getNodeKind);
+KIND_BASE(CHEdge, getEdgeKind);
+#undef KIND_BASE
+
+template <typename T> using KindBaseT = typename KindBaseHelper<T>::type;
+///@}
+
+/// @brief Keeps a map from IDs to T objects, such as XXNode.
+/// @tparam T: The type of the objects.
+template <typename T> class ReaderIDToObjMap
+{
+private:
+    using IDToPairMapTy = OrderedMap<unsigned, std::pair<const cJSON*, T*>>;
+    IDToPairMapTy idMap;
+
+public:
+    template <typename IdObjCreator>
+    /// idObjcreator : (const cJSON*) -> (id, T*) with id set
+    void createObjs(const cJSON* idObjArrayJson, IdObjCreator idObjCreator)
+    {
+        assert(idMap.empty() &&
+               "idToObjMap should be empty when creating objects");
+        ABORT_IFNOT(jsonIsArray(idObjArrayJson), "expects an array");
+
+        jsonForEach(objJson, idObjArrayJson)
+        {
+            ABORT_IFNOT(jsonIsObject(objJson), "expects an object");
+            const cJSON* objFieldJson = objJson->child;
+            // creator is allowed to change objFieldJson
+            auto idObj = idObjCreator(objFieldJson);
+            auto pair = std::pair<const cJSON*, T*>(objFieldJson, idObj.second);
+            bool inserted = idMap.emplace(idObj.first, pair).second;
+            ABORT_IFNOT(inserted, "ID " << idObj.first << " duplicated in "
+                        << idObjArrayJson->string);
+        }
+    }
+
+    T* getPtr(unsigned id) const
+    {
+        auto it = idMap.find(id);
+        ABORT_IFNOT(it != idMap.end(), "ID " << id << " not found");
+        return it->second.second;
+    }
+
+    template <typename FillFunc> void fillObjs(FillFunc fillFunc)
+    {
+        for (auto& pair : idMap)
+        {
+            const cJSON* objFieldJson = pair.second.first;
+            T* obj = pair.second.second;
+            fillFunc(objFieldJson, obj);
+
+            ABORT_IFNOT(!objFieldJson, "json should be consumed by filler, but "
+                        << objFieldJson->string << " left");
+        }
+    }
+
+    inline size_t size() const
+    {
+        return idMap.size();
+    }
+
+    template <typename Map> void saveToIDToObjMap(Map& idToObjMap) const
+    {
+        for (auto& pair : idMap)
+        {
+            unsigned id = pair.first;
+            T* obj = pair.second.second;
+            assert(obj && "obj should not be null");
+            idToObjMap.insert(std::make_pair(id, obj));
+        }
+    }
+};
+
+/// @brief Reverse of WriterPtrPool where T is object type without ID field.
+/// @tparam T
+template <typename T> class ReaderPtrPool
+{
+private:
+    std::vector<const cJSON*> jsonArray;
+    std::vector<T*> ptrPool;
+
+public:
+    inline void reserve(size_t size)
+    {
+        jsonArray.reserve(size);
+        ptrPool.reserve(size);
+    }
+
+    /// @brief
+    /// @tparam Creator
+    /// @param objArrayJson
+    /// @param creator
+    template <typename Creator>
+    void createObjs(const cJSON* objArrayJson, Creator creator)
+    {
+        assert(jsonArray.empty() &&
+               "jsonArray should be empty when creating objects");
+        ABORT_IFNOT(jsonIsArray(objArrayJson), "expects an array");
+
+        jsonForEach(objJson, objArrayJson)
+        {
+            ABORT_IFNOT(jsonIsObject(objJson), "expects objects in array");
+            const cJSON* objFieldJson = objJson->child;
+            T* obj = creator(objFieldJson);
+            jsonArray.push_back(objFieldJson);
+            ptrPool.push_back(obj);
+        }
+    }
+
+    T* getPtr(size_t id) const
+    {
+        ABORT_IFNOT(id <= ptrPool.size(),
+                    "Invalid ID " << id << ". Max ID = " << ptrPool.size());
+        return id ? ptrPool[id - 1] : nullptr;
+    }
+
+    template <typename FillFunc> void fillObjs(FillFunc fillFunc)
+    {
+        assert(jsonArray.size() == ptrPool.size() &&
+               "jsonArray and ptrPool should have same size");
+        for (size_t i = 0; i < jsonArray.size(); ++i)
+        {
+            const cJSON*& objFieldJson = jsonArray[i];
+            fillFunc(objFieldJson, ptrPool[i]);
+            ABORT_IFNOT(!objFieldJson, "json should be consumed by filler, but "
+                        << objFieldJson->string << " left");
+        }
+        jsonArray.clear();
+        jsonArray.shrink_to_fit();
+    }
+
+    inline size_t size() const
+    {
+        return ptrPool.size();
+    }
+};
+
+template <typename NodeTy, typename EdgeTy> class GenericGraphReader
+{
+private:
+    ReaderIDToObjMap<NodeTy> idToNodeMap;
+    ReaderPtrPool<EdgeTy> edgePool;
+
+protected:
+    const cJSON* graphFieldJson = nullptr;
+
+public:
+    template <typename NodeCreator, typename EdgeCreator>
+    void createObjs(const cJSON* graphJson, NodeCreator nodeCreator,
+                    EdgeCreator edgeCreator)
+    {
+        // Read nodeNum
+        const cJSON* nodeNum = graphJson->child;
+        CHECK_JSON_KEY(nodeNum);
+        u32_t numOfNodes = jsonGetNumber(nodeNum);
+        (void)numOfNodes;
+
+        // Read allNode
+        const cJSON* allNode = nodeNum->next;
+        CHECK_JSON_KEY(allNode);
+        idToNodeMap.createObjs(allNode, nodeCreator);
+        // TODO: ABORT_IFNOT(idToNodeMap.size() == numOfNodes, "nodeNum mismatch");
+
+        // Read edgeNum
+        const cJSON* edgeNum = allNode->next;
+        CHECK_JSON_KEY(edgeNum);
+        u32_t numOfEdges = jsonGetNumber(edgeNum);
+        (void)numOfEdges;
+
+        // Read allEdge
+        const cJSON* allEdge = edgeNum->next;
+        CHECK_JSON_KEY(allEdge);
+        edgePool.createObjs(allEdge, edgeCreator);
+        // TODO: ABORT_IFNOT(edgePool.size() == numOfEdges, "edgeNum mismatch");
+
+        // Rest fields
+        assert(!graphFieldJson && "graphFieldJson should be empty");
+        graphFieldJson = allEdge->next;
+    }
+
+    inline NodeTy* getNodePtr(unsigned id) const
+    {
+        return idToNodeMap.getPtr(id);
+    }
+
+    inline EdgeTy* getEdgePtr(unsigned id) const
+    {
+        return edgePool.getPtr(id);
+    }
+
+    template <typename NodeFiller, typename EdgeFiller>
+    void fillObjs(NodeFiller nodeFiller, EdgeFiller edgeFiller)
+    {
+        // GenericNode<> contains field `InEdges` and `OutEdges`, which are
+        // ordered set of edges with comparator `GenericEdge::equalGEdge()`,
+        // which need operands `src` and `dst` to be non-null to get IDs, so we
+        // need to fill nodes first.
+        edgePool.fillObjs(edgeFiller);
+        idToNodeMap.fillObjs(nodeFiller);
+    }
+
+    void saveToGenericGraph(GenericGraph<NodeTy, EdgeTy>* graph) const
+    {
+        graph->edgeNum = edgePool.size();
+        graph->nodeNum = idToNodeMap.size();
+        idToNodeMap.saveToIDToObjMap(graph->IDToNodeMap);
+    }
+
+    const cJSON* getFieldJson() const
+    {
+        return graphFieldJson;
+    }
+};
+
+class SymbolTableInfoReader
+{
+    friend class SVFIRReader;
+
+private:
+    const cJSON* symTabFieldJson = nullptr;
+    ReaderIDToObjMap<MemObj> memObjMap;
+
+public:
+    inline MemObj* getMemObjPtr(unsigned id) const
+    {
+        return memObjMap.getPtr(id);
+    }
+
+    template <typename MemObjCreator>
+    void createObjs(const cJSON* symTabJson, MemObjCreator memObjCreator)
+    {
+        assert(!symTabFieldJson && "symTabFieldJson should be empty");
+        ABORT_IFNOT(jsonIsObject(symTabJson), "symTableJson is not an object?");
+
+        const cJSON* const allMemObj = symTabJson->child;
+        CHECK_JSON_KEY(allMemObj);
+        memObjMap.createObjs(allMemObj, memObjCreator);
+
+        symTabFieldJson = allMemObj->next;
+    }
+
+    inline const cJSON* getFieldJson() const
+    {
+        return symTabFieldJson;
+    }
+};
+
+using GenericICFGReader = GenericGraphReader<ICFGNode, ICFGEdge>;
+using CHGraphReader = GenericGraphReader<CHNode, CHEdge>;
+using IRGraphReader = GenericGraphReader<SVFVar, SVFStmt>;
+
+class ICFGReader : public GenericICFGReader
+{
+    // friend class SVFIRReader;
+
+private:
+    ReaderPtrPool<SVFLoop> svfLoopPool;
+
+public:
+    template <typename NodeCreator, typename EdgeCreator, typename SVFLoopCreator>
+    void createObjs(const cJSON* icfgJson, NodeCreator nodeCreator,
+                    EdgeCreator edgeCreator, SVFLoopCreator svfLoopCreator)
+    {
+        GenericICFGReader::createObjs(icfgJson, nodeCreator, edgeCreator);
+
+        const cJSON* const allSvfLoop = graphFieldJson;
+        CHECK_JSON_KEY(allSvfLoop);
+        svfLoopPool.createObjs(graphFieldJson, svfLoopCreator);
+        graphFieldJson = allSvfLoop->next;
+    }
+
+    inline SVFLoop* getSVFLoopPtr(size_t id) const
+    {
+        return svfLoopPool.getPtr(id);
+    }
+
+    template <typename NodeFiller, typename EdgeFiller, typename LoopFiller>
+    void fillObjs(NodeFiller nodeFiller, EdgeFiller edgeFiller,
+                  LoopFiller loopFiller)
+    {
+        GenericICFGReader::fillObjs(nodeFiller, edgeFiller);
+        svfLoopPool.fillObjs(loopFiller);
+    }
+};
+
+class SVFModuleReader
+{
+    const cJSON* svfModuleFieldJson = nullptr;
+    ReaderPtrPool<SVFType> svfTypePool;
+    ReaderPtrPool<StInfo> stInfoPool;
+    ReaderPtrPool<SVFValue> svfValuePool;
+
+public:
+    template <typename SVFTypeCreator, typename SVFTypeFiller,
+              typename SVFValueCreator, typename SVFValueFiller,
+              typename StInfoCreator>
+    void createObjs(const cJSON* svfModuleJson, SVFTypeCreator typeCreator,
+                    SVFTypeFiller typeFiller, SVFValueCreator valueCreator,
+                    SVFValueFiller valueFiller, StInfoCreator stInfoCreator)
+    {
+        assert(!svfModuleFieldJson && "SVFModule Already created?");
+        ABORT_IFNOT(jsonIsObject(svfModuleJson),
+                    "svfModuleJson not an JSON object?");
+
+        const cJSON* const allSVFType = svfModuleJson->child;
+        CHECK_JSON_KEY(allSVFType);
+        svfTypePool.createObjs(allSVFType, typeCreator);
+
+        const cJSON* const allStInfo = allSVFType->next;
+        CHECK_JSON_KEY(allStInfo);
+        stInfoPool.createObjs(allStInfo, stInfoCreator); // Only need SVFType*
+
+        svfTypePool.fillObjs(typeFiller); // Only need SVFType* & StInfo*
+
+        const cJSON* const allSVFValue = allStInfo->next;
+        CHECK_JSON_KEY(allSVFValue);
+        svfValuePool.createObjs(allSVFValue, valueCreator);
+        svfValuePool.fillObjs(valueFiller); // Need SVFType* & SVFValue*
+
+        svfModuleFieldJson = allSVFValue->next;
+    }
+
+    inline SVFValue* getSVFValuePtr(size_t id) const
+    {
+        return svfValuePool.getPtr(id);
+    }
+    inline SVFType* getSVFTypePtr(size_t id) const
+    {
+        return svfTypePool.getPtr(id);
+    }
+    inline StInfo* getStInfoPtr(size_t id) const
+    {
+        return stInfoPool.getPtr(id);
+    }
+
+    const cJSON* getFieldJson() const
+    {
+        return svfModuleFieldJson;
+    }
+};
+
+/* SVFIRReader
+ * Read SVFIR from JSON
+ */
+
+class SVFIRReader
+{
+private:
+    SVFModuleReader svfModuleReader;
+    SymbolTableInfoReader symTableReader;
+    ICFGReader icfgReader;
+    CHGraphReader chGraphReader;
+    IRGraphReader irGraphReader;
+
+public:
+    static SVFIR* read(const std::string& path);
+
+    static void readJson(const cJSON* obj, bool& flag);
+    static void readJson(const cJSON* obj, unsigned& val);
+    static void readJson(const cJSON* obj, int& val);
+    static void readJson(const cJSON* obj, float& val);
+    static void readJson(const cJSON* obj, unsigned long& val);
+    static void readJson(const cJSON* obj, long long& val);
+    static void readJson(const cJSON* obj, unsigned long long& val);
+    static void readJson(const cJSON* obj, std::string& str);
+
+    // Helper functions
+    static inline s64_t applyEdgeMask(u64_t edgeFlag)
+    {
+        return edgeFlag & GenericEdge<void>::EdgeKindMask;
+    }
+    template <typename T>
+    static inline void setEdgeFlag(GenericEdge<T>* edge,
+                                   typename GenericEdge<T>::GEdgeFlag edgeFlag)
+    {
+        edge->edgeFlag = edgeFlag;
+    }
+
+private:
+    using GNodeK = GenericNode<int, GenericEdge<void>>::GNodeK;
+    using GEdgeFlag = GenericEdge<void>::GEdgeFlag;
+    using GEdgeKind = GenericEdge<void>::GEdgeKind;
+    static ICFGNode* createICFGNode(NodeID id, GNodeK type);
+    static ICFGEdge* createICFGEdge(GEdgeKind kind);
+    static CHNode* createCHNode(NodeID id, GNodeK kind);
+    static CHEdge* createCHEdge(GEdgeKind kind);
+    static SVFVar* createPAGNode(NodeID id, GNodeK kind);
+    static SVFStmt* createPAGEdge(GEdgeKind kind);
+
+    template <typename EdgeCreator>
+    static inline auto createEdgeWithFlag(GEdgeFlag flag, EdgeCreator creator)
+    {
+        auto kind = SVFIRReader::applyEdgeMask(flag);
+        auto edge = creator(kind);
+        setEdgeFlag(edge, flag);
+        return edge;
+    }
+
+    SVFIR* read(const cJSON* root);
+    const cJSON* createObjs(const cJSON* root);
+
+    void readJson(SymbolTableInfo*& symTabInfo);
+    void readJson(IRGraph*& graph); // IRGraph Graph
+    void readJson(ICFG*& icfg);     // ICFG Graph
+    void readJson(CHGraph*& graph); // CHGraph Graph
+    void readJson(SVFModule*& module);
+
+    void readJson(const cJSON* obj, SVFType*& type);
+    void readJson(const cJSON* obj, StInfo*& stInfo);
+    void readJson(const cJSON* obj, SVFValue*& value);
+
+    void readJson(const cJSON* obj, SVFVar*& var);    // IRGraph Node
+    void readJson(const cJSON* obj, SVFStmt*& stmt);  // IRGraph Edge
+    void readJson(const cJSON* obj, ICFGNode*& node); // ICFG Node
+    void readJson(const cJSON* obj, ICFGEdge*& edge); // ICFG Edge
+    // void readJson(const cJSON* obj, CHGraph*& graph); // CHGraph Graph
+    void readJson(const cJSON* obj, CHNode*& node); // CHGraph Node
+    void readJson(const cJSON* obj, CHEdge*& edge); // CHGraph Edge
+    void readJson(const cJSON* obj, CallSite& cs); // CHGraph's csToClassMap
+
+    void readJson(const cJSON* obj, LocationSet& ls);
+    void readJson(const cJSON* obj, SVFLoop*& loop);
+    void readJson(const cJSON* obj, MemObj*& memObj);
+    void readJson(const cJSON* obj,
+                  ObjTypeInfo*& objTypeInfo); // Only owned by MemObj
+    void readJson(const cJSON* obj,
+                  SVFLoopAndDomInfo*& ldInfo); // Only owned by SVFFunction
+
+    template <unsigned ElementSize>
+    inline void readJson(const cJSON* obj, SparseBitVector<ElementSize>& bv)
+    {
+        readJson(obj, bv.Elements);
+    }
+
+    template <unsigned ElementSize>
+    inline void readJson(const cJSON* obj,
+                         SparseBitVectorElement<ElementSize>& element)
+    {
+        readJson(obj, element.Bits);
+    }
+
+    /// @brief Read a pointer of some child class of
+    /// SVFType/SVFValue/SVFVar/SVFStmt/ICFGNode/ICFGEdge/CHNode/CHEdge
+    template <typename T>
+    inline SVFUtil::void_t<KindBaseT<T>> readJson(const cJSON* obj, T*& ptr)
+    {
+        // TODO: Can be optimized?
+        KindBaseT<T>* basePtr = ptr;
+        readJson(obj, basePtr);
+        if (!basePtr)
+            return; // ptr is nullptr when read
+        ptr = SVFUtil::dyn_cast<T>(basePtr);
+        ABORT_IFNOT(ptr, "Cast: " << obj->string << " shoudn't have kind "
+                    << KindBaseHelper<T>::getKind(ptr));
+    }
+
+    /// Read a const pointer
+    template <typename T> inline void readJson(const cJSON* obj, const T*& cptr)
+    {
+        assert(!cptr && "const pointer should be NULL");
+        T* ptr{};
+        readJson(obj, ptr);
+        cptr = ptr;
+    }
+
+    template <typename T1, typename T2>
+    void readJson(const cJSON* obj, std::pair<T1, T2>& pair)
+    {
+        auto jpair = jsonUnpackPair(obj);
+        readJson(jpair.first, pair.first);
+        readJson(jpair.second, pair.second);
+    }
+
+    template <typename T, size_t N>
+    void readJson(const cJSON* obj, T (&array)[N])
+    {
+        static_assert(N > 0, "array size should be greater than 0");
+        ABORT_IFNOT(jsonIsArray(obj), "array expects an array");
+        size_t i = 0;
+        jsonForEach(elemJson, obj)
+        {
+            readJson(elemJson, array[i]);
+            if (++i >= N)
+                break;
+        }
+        ABORT_IFNOT(i == N, "expect array of size " << N);
+    }
+
+    template <typename C>
+    std::enable_if_t<SVFUtil::is_sequence_container_v<C>> readJson(
+        const cJSON* obj, C& container)
+    {
+        using T = typename C::value_type;
+        assert(container.empty() && "container should be empty");
+        ABORT_IFNOT(jsonIsArray(obj), "vector expects an array");
+        jsonForEach(elemJson, obj)
+        {
+            container.push_back(T{});
+            readJson(elemJson, container.back());
+        }
+    }
+
+    template <typename C>
+    std::enable_if_t<SVFUtil::is_map_v<C>> readJson(const cJSON* obj, C& map)
+    {
+        assert(map.empty() && "map should be empty");
+        ABORT_IFNOT(jsonIsMap(obj), "expects an map (represted by array)");
+        jsonForEach(elemJson, obj)
+        {
+            auto jpair = jsonUnpackPair(elemJson);
+            typename C::key_type key{};
+            readJson(jpair.first, key);
+            auto it = map.emplace(std::move(key), typename C::mapped_type{});
+            ABORT_IFNOT(it.second, "Duplicated map key");
+            readJson(jpair.second, it.first->second);
+        }
+    }
+
+    template <typename C>
+    std::enable_if_t<SVFUtil::is_set_v<C>> readJson(const cJSON* obj, C& set)
+    {
+        using T = typename C::value_type;
+        assert(set.empty() && "set should be empty");
+        ABORT_IFNOT(jsonIsArray(obj), "expects an array");
+        jsonForEach(elemJson, obj)
+        {
+            T elem{};
+            readJson(elemJson, elem);
+            auto inserted = set.insert(std::move(elem)).second;
+            ABORT_IFNOT(inserted, "Duplicated set element");
+        }
+    }
+
+    // IGRaph
+    void virtFill(const cJSON*& fieldJson, SVFVar* var);
+    void fill(const cJSON*& fieldJson, SVFVar* var);
+    void fill(const cJSON*& fieldJson, ValVar* var);
+    void fill(const cJSON*& fieldJson, ObjVar* var);
+    void fill(const cJSON*& fieldJson, GepValVar* var);
+    void fill(const cJSON*& fieldJson, GepObjVar* var);
+    void fill(const cJSON*& fieldJson, FIObjVar* var);
+    void fill(const cJSON*& fieldJson, RetPN* var);
+    void fill(const cJSON*& fieldJson, VarArgPN* var);
+    void fill(const cJSON*& fieldJson, DummyValVar* var);
+    void fill(const cJSON*& fieldJson, DummyObjVar* var);
+
+    void virtFill(const cJSON*& fieldJson, SVFStmt* stmt);
+    void fill(const cJSON*& fieldJson, SVFStmt* stmt);
+    void fill(const cJSON*& fieldJson, AssignStmt* stmt);
+    void fill(const cJSON*& fieldJson, AddrStmt* stmt);
+    void fill(const cJSON*& fieldJson, CopyStmt* stmt);
+    void fill(const cJSON*& fieldJson, StoreStmt* stmt);
+    void fill(const cJSON*& fieldJson, LoadStmt* stmt);
+    void fill(const cJSON*& fieldJson, GepStmt* stmt);
+    void fill(const cJSON*& fieldJson, CallPE* stmt);
+    void fill(const cJSON*& fieldJson, RetPE* stmt);
+    void fill(const cJSON*& fieldJson, MultiOpndStmt* stmt);
+    void fill(const cJSON*& fieldJson, PhiStmt* stmt);
+    void fill(const cJSON*& fieldJson, SelectStmt* stmt);
+    void fill(const cJSON*& fieldJson, CmpStmt* stmt);
+    void fill(const cJSON*& fieldJson, BinaryOPStmt* stmt);
+    void fill(const cJSON*& fieldJson, UnaryOPStmt* stmt);
+    void fill(const cJSON*& fieldJson, BranchStmt* stmt);
+    void fill(const cJSON*& fieldJson, TDForkPE* stmt);
+    void fill(const cJSON*& fieldJson, TDJoinPE* stmt);
+
+    void fill(const cJSON*& fieldJson, MemObj* memObj);
+    void fill(const cJSON*& fieldJson, StInfo* stInfo);
+    // ICFG
+    void virtFill(const cJSON*& fieldJson, ICFGNode* node);
+    void fill(const cJSON*& fieldJson, ICFGNode* node);
+    void fill(const cJSON*& fieldJson, GlobalICFGNode* node);
+    void fill(const cJSON*& fieldJson, IntraICFGNode* node);
+    void fill(const cJSON*& fieldJson, InterICFGNode* node);
+    void fill(const cJSON*& fieldJson, FunEntryICFGNode* node);
+    void fill(const cJSON*& fieldJson, FunExitICFGNode* node);
+    void fill(const cJSON*& fieldJson, CallICFGNode* node);
+    void fill(const cJSON*& fieldJson, RetICFGNode* node);
+
+    void virtFill(const cJSON*& fieldJson, ICFGEdge* node);
+    void fill(const cJSON*& fieldJson, ICFGEdge* edge);
+    void fill(const cJSON*& fieldJson, IntraCFGEdge* edge);
+    void fill(const cJSON*& fieldJson, CallCFGEdge* edge);
+    void fill(const cJSON*& fieldJson, RetCFGEdge* edge);
+
+    void fill(const cJSON*& fieldJson, SVFLoop* loop);
+    // CHGraph
+    void virtFill(const cJSON*& fieldJson, CHNode* node);
+    void virtFill(const cJSON*& fieldJson, CHEdge* edge);
+
+    // SVFModule
+    void virtFill(const cJSON*& fieldJson, SVFValue* value);
+    void fill(const cJSON*& fieldJson, SVFValue* value);
+    void fill(const cJSON*& fieldJson, SVFFunction* value);
+    void fill(const cJSON*& fieldJson, SVFBasicBlock* value);
+    void fill(const cJSON*& fieldJson, SVFInstruction* value);
+    void fill(const cJSON*& fieldJson, SVFCallInst* value);
+    void fill(const cJSON*& fieldJson, SVFVirtualCallInst* value);
+    void fill(const cJSON*& fieldJson, SVFConstant* value);
+    void fill(const cJSON*& fieldJson, SVFGlobalValue* value);
+    void fill(const cJSON*& fieldJson, SVFArgument* value);
+    void fill(const cJSON*& fieldJson, SVFConstantData* value);
+    void fill(const cJSON*& fieldJson, SVFConstantInt* value);
+    void fill(const cJSON*& fieldJson, SVFConstantFP* value);
+    void fill(const cJSON*& fieldJson, SVFConstantNullPtr* value);
+    void fill(const cJSON*& fieldJson, SVFBlackHoleValue* value);
+    void fill(const cJSON*& fieldJson, SVFOtherValue* value);
+    void fill(const cJSON*& fieldJson, SVFMetadataAsValue* value);
+
+    void virtFill(const cJSON*& fieldJson, SVFType* type);
+    void fill(const cJSON*& fieldJson, SVFType* type);
+    void fill(const cJSON*& fieldJson, SVFPointerType* type);
+    void fill(const cJSON*& fieldJson, SVFIntegerType* type);
+    void fill(const cJSON*& fieldJson, SVFFunctionType* type);
+    void fill(const cJSON*& fieldJson, SVFStructType* type);
+    void fill(const cJSON*& fieldJson, SVFArrayType* type);
+    void fill(const cJSON*& fieldJson, SVFOtherType* type);
+
+    template <typename NodeTy, typename EdgeTy>
+    void fill(const cJSON*& fieldJson, GenericNode<NodeTy, EdgeTy>* node)
+    {
+        // id and nodeKind have already been read.
+        JSON_READ_FIELD_FWD(fieldJson, node, InEdges);
+        JSON_READ_FIELD_FWD(fieldJson, node, OutEdges);
+    }
+
+    template <typename NodeTy>
+    void fill(const cJSON*& fieldJson, GenericEdge<NodeTy>* edge)
+    {
+        // edgeFlag has already been read.
+        JSON_READ_FIELD_FWD(fieldJson, edge, src);
+        JSON_READ_FIELD_FWD(fieldJson, edge, dst);
+    }
+};
+
 } // namespace SVF
 
-#endif // !INCLUDE_SVFIRRW_H_
+#endif // !INCLUDE_SVFIRRW_H_