svf-tools 1.0.563 → 1.0.564

package/include/Util/PTAStat.h

@@ -48,95 +48,16 @@ class PointerAnalysis;
 class PTAStat: public SVFStat
 {
 public:
-    static const char* TotalAnalysisTime; ///< Total analysis time
-    static const char* SCCDetectionTime; ///< Total SCC detection time
-    static const char* SCCMergeTime; ///< Total SCC merge time
-
-    static const char* ProcessLoadStoreTime;///< time of processing loads and stores
-    static const char* ProcessCopyGepTime;	///< time of processing copys and geps
-    static const char* UpdateCallGraphTime;	///< time of updating call graph
-
-    static const char* TotalNumOfPointers;	///< Total SVFIR value node
-    static const char* TotalNumOfObjects;	///< Total SVFIR object node
-    static const char* TotalNumOfFieldObjects;	///< Total SVFIR field object node
-    static const char* MaxStructSize;	///< Max struct size
-    static const char* TotalNumOfEdges;	///< Total SVFIR edge number
-
-    static const char* NumOfAddrs;		///< SVFIR addr edge
-    static const char* NumOfLoads;		///< SVFIR load edge
-    static const char* NumOfStores;		///< SVFIR store edge
-    static const char* NumOfCopys;		///< SVFIR copy edge
-    static const char* NumOfGeps;		///< SVFIR gep edge
-    static const char* NumOfCalls;		///< SVFIR call edge
-    static const char* NumOfReturns;	///< SVFIR return edge
-
-    static const char* NumOfProcessedAddrs;		///< SVFIR processed addr edge
-    static const char* NumOfProcessedLoads;		///< SVFIR processed load edge
-    static const char* NumOfProcessedStores;	///< SVFIR processed store edge
-    static const char* NumOfProcessedCopys;		///< SVFIR processed copy edge
-    static const char* NumOfProcessedGeps;		///< SVFIR processed gep edge
-
-    static const char* NumOfSfr;                ///< num of field representatives
-    static const char* NumOfFieldExpand;
-
-    static const char* NumOfFunctionObjs;	///< Function numbers
-    static const char* NumOfGlobalObjs;	///< SVFIR global object node
-    static const char* NumOfHeapObjs;	///< SVFIR heap object node
-    static const char* NumOfStackObjs;	///< SVFIR stack object node
-
-    static const char* NumOfObjsHasVarStruct;	///< SVFIR object node has var struct (maybe nested with array)
-    static const char* NumOfObjsHasVarArray;	///< SVFIR object node has var array (maybe nested with struct)
-    static const char* NumOfObjsHasConstStruct;	///< SVFIR object node has const struct (maybe nested with array)
-    static const char* NumOfObjsHasConstArray;	///< SVFIR object node has const array (maybe nested with struct)
-    static const char* NumOfNonPtrObjs;	///< SVFIR object node which is non pointer type object (do not have pts)
-    static const char* NumOfConstantObjs;	///< SVFIR object node which is purely constant
-
-    static const char* NumberOfFieldInsensitiveObj;
-    static const char* NumberOfFieldSensitiveObj;
-
-    static const char* NumOfPointers;	///< SVFIR value node, each of them maps to a llvm value
-    static const char* NumOfGepFieldPointers;	///< SVFIR gep value node (field value, dynamically created dummy node)
-
-    static const char* NumOfMemObjects;	///< SVFIR object node, each of them maps to a llvm value
-    static const char* NumOfGepFieldObjects;	///< SVFIR gep object node (field obj, dynamically created dummy node)
-
-    static const char* AveragePointsToSetSize;		///< Average points-to size of all variables
-    static const char* AverageTopLevPointsToSetSize; ///< Average points-to size of top-level variables
-    static const char* MaxPointsToSetSize;			///< Max points-to size
-
-    static const char* NumOfIterations;	///< Number of iterations during resolution
-
-    static const char* NumOfIndirectCallSites;	///< Number of indirect callsites
-    static const char* NumOfIndirectEdgeSolved;	///< Number of indirect calledge resolved
-
-    static const char* NumOfSCCDetection; ///< Number of scc detection performed
-    static const char* NumOfCycles;   ///< Number of scc cycles detected
-    static const char* NumOfPWCCycles;   ///< Number of scc cycles detected
-    static const char* NumOfNodesInCycles; ///< Number of nodes in cycles detected
-    static const char* MaxNumOfNodesInSCC;	///< max Number of nodes in one scc
-
-    static const char* NumOfNullPointer;	///< Number of pointers points-to null
-
     PTAStat(PointerAnalysis* p);
     virtual ~PTAStat() {}
 
-    NUMStatMap PTNumStatMap;
     NodeBS localVarInRecursion;
 
-    double startTime;
-    double endTime;
-
     void performStat() override;
 
-    virtual void printStat(std::string str = "") override;
-
     void callgraphStat() override;
 private:
-    void bitcastInstStat();
-    void branchStat();
-
     PointerAnalysis* pta;
-    std::string moduleName;
 };
 
 } // End namespace SVF

package/include/Util/SVFStat.h

@@ -71,6 +71,7 @@ public:
     static double getClk(bool mark = false);
 
     NUMStatMap generalNumMap;
+    NUMStatMap PTNumStatMap;
     TIMEStatMap timeStatMap;
 
     double startTime;
@@ -78,7 +79,7 @@ public:
 
     virtual void performStat() = 0;
 
-    virtual void printStat(std::string str = "") = 0;
+    virtual void printStat(std::string str = "");
 
     virtual void performStatPerQuery(NodeID) {}
 
@@ -91,7 +92,7 @@ public:
     static double timeOfBuildingSVFIR;
 
 private:
-
+    void branchStat();
     std::string moduleName;
 }; // End class SVFStat
 

package/lib/Util/PTAStat.cpp

@@ -2,7 +2,7 @@
 //
 //                     SVF: Static Value-Flow Analysis
 //
-// Copyright (C) <2013-2017>  <Yulei Sui>
+// Copyright (C) <2013->  <Yulei Sui>
 //
 
 // This program is free software: you can redistribute it and/or modify
@@ -32,191 +32,33 @@
 #include "Util/PTAStat.h"
 #include "MemoryModel/PointerAnalysisImpl.h"
 #include "MemoryModel/SVFIR.h"
-#include "Util/Options.h"
 
 using namespace SVF;
 using namespace std;
 
-const char* PTAStat:: TotalAnalysisTime = "TotalTime";	///< SVFIR value nodes ？？
-const char* PTAStat:: SCCDetectionTime = "SCCDetectTime"; ///< Total SCC detection time
-const char* PTAStat:: SCCMergeTime = "SCCMergeTime"; ///< Total SCC merge time
-
-const char* PTAStat:: ProcessLoadStoreTime = "LoadStoreTime";	///< process load and store time
-const char* PTAStat:: ProcessCopyGepTime = "CopyGepTime";	///< process copy and gep time
-const char* PTAStat:: UpdateCallGraphTime = "UpdateCGTime";	///< process copy and gep time ？？
-
-const char* PTAStat:: TotalNumOfPointers = "TotalPointers";	///< SVFIR value nodes
-const char* PTAStat:: TotalNumOfObjects = "TotalObjects";	///< Total SVFIR object node
-const char* PTAStat:: TotalNumOfFieldObjects = "TotalFieldObjects";	///< Total SVFIR field object node
-const char* PTAStat:: MaxStructSize = "MaxStructSize";	///< Max struct size (bytes)
-const char* PTAStat:: TotalNumOfEdges = "TotalSVFStmts";	///< Total SVFIR edge number
-
-const char* PTAStat:: NumOfFunctionObjs = "FunctionObjs";	///< function numbers
-const char* PTAStat:: NumOfGlobalObjs = "GlobalObjs";	///< SVFIR global object node
-const char* PTAStat:: NumOfHeapObjs  = "HeapObjs";	///< SVFIR heap object node
-const char* PTAStat:: NumOfStackObjs = "StackObjs";	///< SVFIR stack object node
-
-const char* PTAStat::NumberOfFieldInsensitiveObj = "FIObjNum";
-const char* PTAStat::NumberOfFieldSensitiveObj = "FSObjNum";
-
-const char* PTAStat:: NumOfObjsHasVarStruct = "VarStructObj";	///< SVFIR object node has struct (maybe nested with array)
-const char* PTAStat:: NumOfObjsHasVarArray = "VarArrayObj";	///< SVFIR object node has array (maybe nested with struct)
-const char* PTAStat:: NumOfObjsHasConstStruct = "ConstStructObj";	///< SVFIR object node has const struct (maybe nested with array)
-const char* PTAStat:: NumOfObjsHasConstArray = "ConstArrayObj";	///< SVFIR object node has const array (maybe nested with struct)
-const char* PTAStat:: NumOfNonPtrObjs = "NonPtrObj";	///< SVFIR object node which is non pointer type object (do not have pts)
-const char* PTAStat:: NumOfConstantObjs = "ConstantObj";	///< SVFIR object node which is purely scalar
-
-const char* PTAStat:: NumOfAddrs = "AddrsNum";		///< SVFIR addr edge
-const char* PTAStat:: NumOfLoads = "LoadsNum";		///< SVFIR load edge
-const char* PTAStat:: NumOfStores = "StoresNum";		///< SVFIR store edge
-const char* PTAStat:: NumOfCopys = "CopysNum";		///< SVFIR copy edge
-const char* PTAStat:: NumOfGeps = "GepsNum";		///< SVFIR gep edge
-const char* PTAStat:: NumOfCalls = "CallsNum";		///< SVFIR call edge
-const char* PTAStat:: NumOfReturns = "ReturnsNum";	///< SVFIR return edge
-
-const char* PTAStat:: NumOfProcessedAddrs = "AddrProcessed";		///< SVFIR addr processed edge
-const char* PTAStat:: NumOfProcessedLoads = "LoadProcessed";		///< SVFIR load processed edge
-const char* PTAStat:: NumOfProcessedStores = "StoreProcessed";		///< SVFIR store processed edge
-const char* PTAStat:: NumOfProcessedCopys = "CopyProcessed";		///< SVFIR copy processed edge
-const char* PTAStat:: NumOfProcessedGeps = "GepProcessed";		///< SVFIR gep processed edge
-
-const char* PTAStat::NumOfSfr = "NumOfSFRs";                    ///< number of field representatives
-const char* PTAStat::NumOfFieldExpand = "NumOfFieldExpand";
-
-const char* PTAStat:: NumOfPointers = "Pointers";	///< SVFIR value node, each of them maps to a llvm value
-const char* PTAStat:: NumOfGepFieldPointers = "DYFieldPtrs";	///< SVFIR gep value node (field value, dynamically created dummy node)
-
-const char* PTAStat:: NumOfMemObjects = "MemObjects";	///< SVFIR object node, each of them maps to a llvm value
-const char* PTAStat:: NumOfGepFieldObjects = "DYFieldObjs";	///< SVFIR gep object node (field obj, dynamically created dummy node)
-
-const char* PTAStat:: AveragePointsToSetSize = "AvgPtsSetSize";		///< Average Points-to set size
-const char* PTAStat:: AverageTopLevPointsToSetSize = "AvgTopLvlPtsSize";		///< Average Points-to set size of top level pointers
-const char* PTAStat:: MaxPointsToSetSize = "MaxPtsSetSize";		///< Max Points-to set size
-
-const char* PTAStat:: NumOfIterations = "Iterations";	///< Number of iterations during resolution
-
-const char* PTAStat:: NumOfIndirectCallSites = "IndCallSites";	///< Number of indirect callsites
-const char* PTAStat:: NumOfIndirectEdgeSolved = "IndEdgeSolved";	///< Number of indirect calledge resolved
-
-const char* PTAStat:: NumOfSCCDetection = "NumOfSCCDetect";   ///< Number of scc detection performed
-const char* PTAStat:: NumOfCycles = "TotalCycleNum";   ///< Number of scc cycles detected
-const char* PTAStat:: NumOfPWCCycles = "TotalPWCCycleNum";   ///< Number of pwc scc cycles detected
-const char* PTAStat:: NumOfNodesInCycles = "NodesInCycles"; ///< Number of nodes in cycles detected
-const char* PTAStat:: MaxNumOfNodesInSCC = "MaxNodesInSCC";	///< max Number of nodes in one scc cycle
-
-const char* PTAStat:: NumOfNullPointer = "NullPointer";	///< Number of pointers points-to null
-
-PTAStat::PTAStat(PointerAnalysis* p) : SVFStat(), startTime(0), endTime(0), pta(p)
+PTAStat::PTAStat(PointerAnalysis* p) : SVFStat(), pta(p)
 {
-
 }
 
 void PTAStat::performStat()
 {
-
     callgraphStat();
 
+    SVFStat::performStat();
+
     SVFIR* pag = SVFIR::getPAG();
-    u32_t numOfFunction = 0;
-    u32_t numOfGlobal = 0;
-    u32_t numOfStack = 0;
-    u32_t numOfHeap = 0;
-    u32_t numOfHasVarArray = 0;
-    u32_t numOfHasVarStruct = 0;
-    u32_t numOfHasConstArray = 0;
-    u32_t numOfHasConstStruct = 0;
-    u32_t numOfScalar = 0;
-    u32_t numOfConstant = 0;
-    u32_t fiObjNumber = 0;
-    u32_t fsObjNumber = 0;
-    Set<SymID> memObjSet;
     for(SVFIR::iterator it = pag->begin(), eit = pag->end(); it!=eit; ++it)
     {
         PAGNode* node = it->second;
-        if(ObjVar* obj = SVFUtil::dyn_cast<ObjVar>(node))
+        if(SVFUtil::isa<ObjVar>(node))
         {
-            const MemObj* mem = obj->getMemObj();
-            if (memObjSet.insert(mem->getId()).second == false)
-                continue;
-            if(mem->isBlackHoleObj())
-                continue;
-            if(mem->isFunction())
-                numOfFunction++;
-            if(mem->isGlobalObj())
-                numOfGlobal++;
-            if(mem->isStack())
-                numOfStack++;
-            if(mem->isHeap())
-                numOfHeap++;
-            if(mem->isVarArray())
-                numOfHasVarArray++;
-            if(mem->isVarStruct())
-                numOfHasVarStruct++;
-            if(mem->isConstantArray())
-                numOfHasConstArray++;
-            if(mem->isConstantStruct())
-                numOfHasConstStruct++;
-            if(mem->hasPtrObj() == false)
-                numOfScalar++;
-            if(mem->isConstDataOrConstGlobal())
-                numOfConstant++;
-
-            if (mem->isFieldInsensitive())
-                fiObjNumber++;
-            else
-                fsObjNumber++;
-
             if(pta->isLocalVarInRecursiveFun(node->getId()))
             {
                 localVarInRecursion.set(node->getId());
             }
         }
     }
-
-
-
-    generalNumMap[TotalNumOfPointers] = pag->getValueNodeNum() + pag->getFieldValNodeNum();
-    generalNumMap[TotalNumOfObjects] = pag->getObjectNodeNum();
-    generalNumMap[TotalNumOfFieldObjects] = pag->getFieldObjNodeNum();
-    generalNumMap[MaxStructSize] = SymbolTableInfo::SymbolInfo()->getMaxStructSize();
-    generalNumMap[TotalNumOfEdges] = pag->getPAGEdgeNum();
-    generalNumMap["TotalPTASVFStmts"] = pag->getPTAPAGEdgeNum();
-    generalNumMap[NumberOfFieldInsensitiveObj] = fiObjNumber;
-    generalNumMap[NumberOfFieldSensitiveObj] = fsObjNumber;
-
-    generalNumMap[NumOfAddrs] = pag->getSVFStmtSet(SVFStmt::Addr).size();
-    generalNumMap[NumOfLoads] = pag->getSVFStmtSet(SVFStmt::Load).size();
-    generalNumMap[NumOfStores] = pag->getSVFStmtSet(SVFStmt::Store).size();
-    generalNumMap[NumOfCopys] =  pag->getSVFStmtSet(SVFStmt::Copy).size();
-    generalNumMap[NumOfGeps] =  pag->getSVFStmtSet(SVFStmt::Gep).size();
-    generalNumMap[NumOfCalls] = pag->getSVFStmtSet(SVFStmt::Call).size();
-    generalNumMap[NumOfReturns] = pag->getSVFStmtSet(SVFStmt::Ret).size();
-
-    generalNumMap[NumOfFunctionObjs] = numOfFunction;
-    generalNumMap[NumOfGlobalObjs] = numOfGlobal;
-    generalNumMap[NumOfHeapObjs]  = numOfHeap;
-    generalNumMap[NumOfStackObjs] = numOfStack;
-
-    generalNumMap[NumOfObjsHasVarStruct] = numOfHasVarStruct;
-    generalNumMap[NumOfObjsHasVarArray] = numOfHasVarArray;
-    generalNumMap[NumOfObjsHasConstStruct] = numOfHasConstStruct;
-    generalNumMap[NumOfObjsHasConstArray] = numOfHasConstArray;
-    generalNumMap[NumOfNonPtrObjs] = numOfScalar;
-    generalNumMap[NumOfConstantObjs] = numOfConstant;
-
-    generalNumMap[NumOfIndirectCallSites] = pag->getIndirectCallsites().size();
-    generalNumMap["TotalCallSite"] = pag->getCallSiteSet().size();
-    generalNumMap["LocalVarInRecur"] = localVarInRecursion.count();
-
-    timeStatMap["LLVMIRTime"] = SVFStat::timeOfBuildingLLVMModule;
-    timeStatMap["SymbolTableTime"] = SVFStat::timeOfBuildingSymbolTable;
-    timeStatMap["SVFIRTime"] = SVFStat::timeOfBuildingSVFIR;
-
-    // REFACTOR-TODO bitcastInstStat();
-    branchStat();
-
-    printStat("General Stats");
-
+    PTNumStatMap["LocalVarInRecur"] = localVarInRecursion.count();
 }
 
 void PTAStat::callgraphStat()
@@ -270,101 +112,7 @@ void PTAStat::callgraphStat()
     PTNumStatMap["TotalEdge"] = totalEdge;
     PTNumStatMap["CalRetPairInCycle"] = edgeInCycle;
 
-    PTAStat::printStat("CallGraph Stats");
+    SVFStat::printStat("CallGraph Stats");
 
     delete callgraphSCC;
 }
-
-void PTAStat::printStat(string statname)
-{
-
-    std::string moduleName(SymbolTableInfo::SymbolInfo()->getModule()->getModuleIdentifier());
-    std::vector<std::string> names = SVFUtil::split(moduleName,'/');
-    if (names.size() > 1)
-    {
-        moduleName = names[names.size() - 1];
-    }
-
-    SVFUtil::outs() << "\n*********" << statname << "***************\n";
-    SVFUtil::outs() << "################ (program : " << moduleName << ")###############\n";
-    SVFUtil::outs().flags(std::ios::left);
-    unsigned field_width = 20;
-    for(NUMStatMap::iterator it = generalNumMap.begin(), eit = generalNumMap.end(); it!=eit; ++it)
-    {
-        // format out put with width 20 space
-        std::cout << std::setw(field_width) << it->first << it->second << "\n";
-    }
-    SVFUtil::outs() << "-------------------------------------------------------\n";
-    for(TIMEStatMap::iterator it = timeStatMap.begin(), eit = timeStatMap.end(); it!=eit; ++it)
-    {
-        // format out put with width 20 space
-        SVFUtil::outs() << std::setw(field_width) << it->first << it->second << "\n";
-    }
-    for(NUMStatMap::iterator it = PTNumStatMap.begin(), eit = PTNumStatMap.end(); it!=eit; ++it)
-    {
-        // format out put with width 20 space
-        SVFUtil::outs() << std::setw(field_width) << it->first << it->second << "\n";
-    }
-
-    SVFUtil::outs() << "#######################################################" << std::endl;
-    SVFUtil::outs().flush();
-    generalNumMap.clear();
-    PTNumStatMap.clear();
-    timeStatMap.clear();
-}
-
-
-/* REFACTOR-TODO
-void PTAStat::bitcastInstStat()
-{
-    SVFModule* module = pta->getModule();
-    u32_t numberOfBitCast = 0;
-    for (SVFModule::llvm_const_iterator funIter = module->llvmFunBegin(), funEiter = module->llvmFunEnd();
-            funIter != funEiter; ++funIter)
-    {
-        const Function* func = *funIter;
-        for (Function::const_iterator bbIt = func->begin(), bbEit = func->end();
-                bbIt != bbEit; ++bbIt)
-        {
-            const BasicBlock& bb = *bbIt;
-            for (BasicBlock::const_iterator instIt = bb.begin(), instEit = bb.end();
-                    instIt != instEit; ++instIt)
-            {
-                const Instruction& inst = *instIt;
-                if (const BitCastInst* bitcast = SVFUtil::dyn_cast<BitCastInst>(&inst))
-                {
-                    if (SVFUtil::isa<PointerType>(bitcast->getSrcTy()))
-                        numberOfBitCast++;
-                }
-            }
-        }
-    }
-
-    generalNumMap["BitCastNumber"] = numberOfBitCast;
-}
-*/
-
-void PTAStat::branchStat()
-{
-    SVFModule* module = pta->getModule();
-    u32_t numOfBB_2Succ = 0;
-    u32_t numOfBB_3Succ = 0;
-    for (SVFModule::llvm_const_iterator funIter = module->llvmFunBegin(), funEiter = module->llvmFunEnd();
-            funIter != funEiter; ++funIter)
-    {
-        const Function* func = *funIter;
-        for (Function::const_iterator bbIt = func->begin(), bbEit = func->end();
-                bbIt != bbEit; ++bbIt)
-        {
-            const BasicBlock& bb = *bbIt;
-            u32_t numOfSucc = bb.getTerminator()->getNumSuccessors();
-            if (numOfSucc == 2)
-                numOfBB_2Succ++;
-            else if (numOfSucc > 2)
-                numOfBB_3Succ++;
-        }
-    }
-
-    generalNumMap["BBWith2Succ"] = numOfBB_2Succ;
-    generalNumMap["BBWith3Succ"] = numOfBB_3Succ;
-}

package/lib/Util/SVFStat.cpp

@@ -2,7 +2,7 @@
 //
 //                     SVF: Static Value-Flow Analysis
 //
-// Copyright (C) <2013-2017>  <Yulei Sui>
+// Copyright (C) <2013->  <Yulei Sui>
 //
 
 // This program is free software: you can redistribute it and/or modify
@@ -31,6 +31,7 @@
 #include "Util/SVFStat.h"
 
 using namespace SVF;
+using namespace std;
 
 double SVFStat::timeOfBuildingLLVMModule = 0;
 double SVFStat::timeOfBuildingSVFIR = 0;
@@ -60,4 +61,198 @@ double SVFStat::getClk(bool mark)
 
     assert(false && "PTAStat::getClk: unknown clock type");
     abort();
-}
+}
+
+void SVFStat::printStat(string statname)
+{
+
+    std::string moduleName(SymbolTableInfo::SymbolInfo()->getModule()->getModuleIdentifier());
+    std::vector<std::string> names = SVFUtil::split(moduleName,'/');
+    if (names.size() > 1)
+    {
+        moduleName = names[names.size() - 1];
+    }
+
+    SVFUtil::outs() << "\n*********" << statname << "***************\n";
+    SVFUtil::outs() << "################ (program : " << moduleName << ")###############\n";
+    SVFUtil::outs().flags(std::ios::left);
+    unsigned field_width = 20;
+    for(NUMStatMap::iterator it = generalNumMap.begin(), eit = generalNumMap.end(); it!=eit; ++it)
+    {
+        // format out put with width 20 space
+        std::cout << std::setw(field_width) << it->first << it->second << "\n";
+    }
+    SVFUtil::outs() << "-------------------------------------------------------\n";
+    for(TIMEStatMap::iterator it = timeStatMap.begin(), eit = timeStatMap.end(); it!=eit; ++it)
+    {
+        // format out put with width 20 space
+        SVFUtil::outs() << std::setw(field_width) << it->first << it->second << "\n";
+    }
+    for(NUMStatMap::iterator it = PTNumStatMap.begin(), eit = PTNumStatMap.end(); it!=eit; ++it)
+    {
+        // format out put with width 20 space
+        SVFUtil::outs() << std::setw(field_width) << it->first << it->second << "\n";
+    }
+
+    SVFUtil::outs() << "#######################################################" << std::endl;
+    SVFUtil::outs().flush();
+    generalNumMap.clear();
+    PTNumStatMap.clear();
+    timeStatMap.clear();
+}
+
+void SVFStat::performStat()
+{
+
+    SVFIR* pag = SVFIR::getPAG();
+    u32_t numOfFunction = 0;
+    u32_t numOfGlobal = 0;
+    u32_t numOfStack = 0;
+    u32_t numOfHeap = 0;
+    u32_t numOfHasVarArray = 0;
+    u32_t numOfHasVarStruct = 0;
+    u32_t numOfHasConstArray = 0;
+    u32_t numOfHasConstStruct = 0;
+    u32_t numOfScalar = 0;
+    u32_t numOfConstant = 0;
+    u32_t fiObjNumber = 0;
+    u32_t fsObjNumber = 0;
+    Set<SymID> memObjSet;
+    for(SVFIR::iterator it = pag->begin(), eit = pag->end(); it!=eit; ++it)
+    {
+        PAGNode* node = it->second;
+        if(ObjVar* obj = SVFUtil::dyn_cast<ObjVar>(node))
+        {
+            const MemObj* mem = obj->getMemObj();
+            if (memObjSet.insert(mem->getId()).second == false)
+                continue;
+            if(mem->isBlackHoleObj())
+                continue;
+            if(mem->isFunction())
+                numOfFunction++;
+            if(mem->isGlobalObj())
+                numOfGlobal++;
+            if(mem->isStack())
+                numOfStack++;
+            if(mem->isHeap())
+                numOfHeap++;
+            if(mem->isVarArray())
+                numOfHasVarArray++;
+            if(mem->isVarStruct())
+                numOfHasVarStruct++;
+            if(mem->isConstantArray())
+                numOfHasConstArray++;
+            if(mem->isConstantStruct())
+                numOfHasConstStruct++;
+            if(mem->hasPtrObj() == false)
+                numOfScalar++;
+            if(mem->isConstDataOrConstGlobal())
+                numOfConstant++;
+
+            if (mem->isFieldInsensitive())
+                fiObjNumber++;
+            else
+                fsObjNumber++;
+        }
+    }
+
+
+
+    generalNumMap["TotalPointers"] = pag->getValueNodeNum() + pag->getFieldValNodeNum();
+    generalNumMap["TotalObjects"] = pag->getObjectNodeNum();
+    generalNumMap["TotalFieldObjects"] = pag->getFieldObjNodeNum();
+    generalNumMap["MaxStructSize"] = SymbolTableInfo::SymbolInfo()->getMaxStructSize();
+    generalNumMap["TotalSVFStmts"] = pag->getPAGEdgeNum();
+    generalNumMap["TotalPTASVFStmts"] = pag->getPTAPAGEdgeNum();
+    generalNumMap["FIObjNum"] = fiObjNumber;
+    generalNumMap["FSObjNum"] = fsObjNumber;
+
+    generalNumMap["AddrsNum"] = pag->getSVFStmtSet(SVFStmt::Addr).size();
+    generalNumMap["LoadsNum"] = pag->getSVFStmtSet(SVFStmt::Load).size();
+    generalNumMap["StoresNum"] = pag->getSVFStmtSet(SVFStmt::Store).size();
+    generalNumMap["CopysNum"] =  pag->getSVFStmtSet(SVFStmt::Copy).size();
+    generalNumMap["GepsNum"] =  pag->getSVFStmtSet(SVFStmt::Gep).size();
+    generalNumMap["CallsNum"] = pag->getSVFStmtSet(SVFStmt::Call).size();
+    generalNumMap["ReturnsNum"] = pag->getSVFStmtSet(SVFStmt::Ret).size();
+
+    generalNumMap["FunctionObjs"] = numOfFunction;
+    generalNumMap["GlobalObjs"] = numOfGlobal;
+    generalNumMap["HeapObjs"]  = numOfHeap;
+    generalNumMap["StackObjs"] = numOfStack;
+
+    generalNumMap["VarStructObj"] = numOfHasVarStruct;
+    generalNumMap["VarArrayObj"] = numOfHasVarArray;
+    generalNumMap["ConstStructObj"] = numOfHasConstStruct;
+    generalNumMap["ConstArrayObj"] = numOfHasConstArray;
+    generalNumMap["NonPtrObj"] = numOfScalar;
+    generalNumMap["ConstantObj"] = numOfConstant;
+
+    generalNumMap["IndCallSites"] = pag->getIndirectCallsites().size();
+    generalNumMap["TotalCallSite"] = pag->getCallSiteSet().size();
+
+    timeStatMap["LLVMIRTime"] = SVFStat::timeOfBuildingLLVMModule;
+    timeStatMap["SymbolTableTime"] = SVFStat::timeOfBuildingSymbolTable;
+    timeStatMap["SVFIRTime"] = SVFStat::timeOfBuildingSVFIR;
+
+    // REFACTOR-TODO bitcastInstStat();
+    branchStat();
+
+    printStat("General Stats");
+
+}
+
+
+void SVFStat::branchStat()
+{
+    SVFModule* module = SVFIR::getPAG()->getModule();
+    u32_t numOfBB_2Succ = 0;
+    u32_t numOfBB_3Succ = 0;
+    for (SVFModule::llvm_const_iterator funIter = module->llvmFunBegin(), funEiter = module->llvmFunEnd();
+            funIter != funEiter; ++funIter)
+    {
+        const Function* func = *funIter;
+        for (Function::const_iterator bbIt = func->begin(), bbEit = func->end();
+                bbIt != bbEit; ++bbIt)
+        {
+            const BasicBlock& bb = *bbIt;
+            u32_t numOfSucc = bb.getTerminator()->getNumSuccessors();
+            if (numOfSucc == 2)
+                numOfBB_2Succ++;
+            else if (numOfSucc > 2)
+                numOfBB_3Succ++;
+        }
+    }
+
+    generalNumMap["BBWith2Succ"] = numOfBB_2Succ;
+    generalNumMap["BBWith3Succ"] = numOfBB_3Succ;
+}
+
+/* REFACTOR-TODO
+void PTAStat::bitcastInstStat()
+{
+    SVFModule* module = pta->getModule();
+    u32_t numberOfBitCast = 0;
+    for (SVFModule::llvm_const_iterator funIter = module->llvmFunBegin(), funEiter = module->llvmFunEnd();
+            funIter != funEiter; ++funIter)
+    {
+        const Function* func = *funIter;
+        for (Function::const_iterator bbIt = func->begin(), bbEit = func->end();
+                bbIt != bbEit; ++bbIt)
+        {
+            const BasicBlock& bb = *bbIt;
+            for (BasicBlock::const_iterator instIt = bb.begin(), instEit = bb.end();
+                    instIt != instEit; ++instIt)
+            {
+                const Instruction& inst = *instIt;
+                if (const BitCastInst* bitcast = SVFUtil::dyn_cast<BitCastInst>(&inst))
+                {
+                    if (SVFUtil::isa<PointerType>(bitcast->getSrcTy()))
+                        numberOfBitCast++;
+                }
+            }
+        }
+    }
+
+    generalNumMap["BitCastNumber"] = numberOfBitCast;
+}
+*/