svf-tools 1.0.562 → 1.0.565

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) {}
 
@@ -86,8 +87,12 @@ public:
 
     virtual void callgraphStat() {}
 
-private:
+    static double timeOfBuildingLLVMModule;
+    static double timeOfBuildingSymbolTable;
+    static double timeOfBuildingSVFIR;
 
+private:
+    void branchStat();
     std::string moduleName;
 }; // End class SVFStat
 

package/lib/CFL/CFGNormalizer.cpp

@@ -49,6 +49,7 @@ CFLGrammar* CFGNormalizer::normalize(GrammarBase *generalGrammar)
     grammar->setAttributeKinds(generalGrammar->getAttrSyms());
     grammar->setKind2AttrsMap(generalGrammar->getKind2AttrsMap());
     grammar->setRawProductions(generalGrammar->getRawProductions());
+    barReplace(grammar);
     ebnfSignReplace('*', grammar);
     ebnfSignReplace('?', grammar);
     ebnf_bin(grammar);
@@ -309,6 +310,36 @@ int CFGNormalizer::ebnfBracketMatch(GrammarBase::Production &prod, int i, CFLGra
     return 0;
 }
 
+void CFGNormalizer::barReplace(CFLGrammar *grammar)
+{
+    for (auto &symbolToProductionsPair : grammar->getRawProductions())
+    {
+        GrammarBase::Productions productions;
+        //GrammarBase::Productions Originalproductions = symbolToProductionsPair.second;
+        for (auto ebnfProduction : symbolToProductionsPair.second)
+        {
+            size_t i = 1;
+            size_t j = 1;
+            while (i < ebnfProduction.size())
+            {
+                if (grammar->kind2Str(ebnfProduction[i].kind) == "|")
+                {
+                    GrammarBase::Production tempPro(ebnfProduction.begin()+j, ebnfProduction.begin()+i);
+                    tempPro.insert(tempPro.begin(), symbolToProductionsPair.first );
+                    productions.insert(tempPro);
+                    j = i+1;
+                }
+                i++;
+            }
+            GrammarBase::Production tempPro(ebnfProduction.begin()+j, ebnfProduction.begin()+i);
+            tempPro.insert(tempPro.begin(), symbolToProductionsPair.first );
+            productions.insert(tempPro);
+        }
+        symbolToProductionsPair.second.clear();
+        symbolToProductionsPair.second = productions;
+    }
+}
+
 void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
 {
     /// Replace Sign Group With tempNonterminal 'X'
@@ -352,6 +383,13 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
                         ebnfProduction.insert(ebnfProduction.begin() + signGroupStart, grammar->str2Symbol(newProductions[groupString]));
                         productions.insert(ebnfProduction);
                     }
+                    else if ( (signGroupStart == 1) && (i == ebnfProduction.size() -1))
+                    {
+                        newProductions[groupString] = grammar->kind2Str(ebnfProduction[0].kind);
+                        productions.erase(ebnfProduction);
+                        ebnfProduction.erase(ebnfProduction.begin() + signGroupStart, ebnfProduction.begin() + i + 1);
+
+                    }
                     else
                     {
                         tempNonterminal = "X";
@@ -379,25 +417,38 @@ void CFGNormalizer::ebnfSignReplace(char sign, CFLGrammar *grammar)
         std::string new_nonterminal = rep.second;
         GrammarBase::Production temp_list = {grammar->str2Symbol(new_nonterminal), grammar->str2Symbol("epsilon")};
         grammar->getRawProductions()[grammar->str2Symbol(new_nonterminal)].insert(temp_list);
-        /// insert second rule for '*' X -> X E for '+' X -> X
+        /// insert second rule for '*' X -> X E for '+' X -> E
         temp_list = {grammar->str2Symbol(new_nonterminal)};
-        if (sign == '*')
+        if (sign == '*' || sign == '?')
         {
             /// Insert Back the Group
             GrammarBase::Production E = strTrans(rep.first, grammar);
             GrammarBase::Production withoutSign = {};
-            for (auto &word : E)
+            if (sign == '*')
             {
-                if (word != grammar->str2Symbol("*")  && word != grammar->str2Symbol("(") && word != grammar->str2Symbol(")"))
+                for (auto &word : E)
                 {
-                    withoutSign.push_back(word);
+                    if (word != grammar->str2Symbol("*")  && word != grammar->str2Symbol("(") && word != grammar->str2Symbol(")"))
+                    {
+                        withoutSign.push_back(word);
+                    }
+                }
+                withoutSign.push_back(grammar->str2Symbol(rep.second));
+            }
+            if (sign == '?')
+            {
+                for (auto &word : E)
+                {
+                    if (word != grammar->str2Symbol("?")  && word != grammar->str2Symbol("(") && word != grammar->str2Symbol(")"))
+                    {
+                        withoutSign.push_back(word);
+                    }
                 }
             }
             temp_list.insert(temp_list.end(), withoutSign.begin(), withoutSign.end());
         }
         grammar->getRawProductions()[grammar->str2Symbol(new_nonterminal)].insert(temp_list);
     }
-
 }
 
 GrammarBase::Production CFGNormalizer::strTrans(std::string LHS, CFLGrammar *grammar)

package/lib/MTA/LockAnalysis.cpp

@@ -591,12 +591,12 @@ bool LockAnalysis::isProtectedByCommonLock(const Instruction *i1, const Instruct
 {
     numOfTotalQueries++;
     bool commonlock = false;
-    DOTIMESTAT(double queryStart = PTAStat::getClk());
+    DOTIMESTAT(double queryStart = PTAStat::getClk(true));
     if (isInsideIntraLock(i1) && isInsideIntraLock(i2))
         commonlock = isProtectedByCommonCILock(i1,i2) ;
     else
         commonlock = isProtectedByCommonCxtLock(i1,i2);
-    DOTIMESTAT(double queryEnd = PTAStat::getClk());
+    DOTIMESTAT(double queryEnd = PTAStat::getClk(true));
     DOTIMESTAT(lockQueriesTime += (queryEnd - queryStart) / TIMEINTERVAL);
     return commonlock;
 }
@@ -667,7 +667,7 @@ bool LockAnalysis::isProtectedByCommonCxtLock(const Instruction *i1, const Instr
  */
 bool LockAnalysis::isInSameSpan(const Instruction *i1, const Instruction *i2)
 {
-    DOTIMESTAT(double queryStart = PTAStat::getClk());
+    DOTIMESTAT(double queryStart = PTAStat::getClk(true));
 
     bool sameSpan = false;
     if (isInsideIntraLock(i1) && isInsideIntraLock(i2))
@@ -675,7 +675,7 @@ bool LockAnalysis::isInSameSpan(const Instruction *i1, const Instruction *i2)
     else
         sameSpan = isInSameCSSpan(i1, i2);
 
-    DOTIMESTAT(double queryEnd = PTAStat::getClk());
+    DOTIMESTAT(double queryEnd = PTAStat::getClk(true));
     DOTIMESTAT(lockQueriesTime += (queryEnd - queryStart) / TIMEINTERVAL);
     return sameSpan;
 }

package/lib/MTA/MHP.cpp

@@ -627,9 +627,9 @@ bool MHP::mayHappenInParallel(const Instruction* i1, const Instruction* i2)
 {
     numOfTotalQueries++;
 
-    DOTIMESTAT(double queryStart = PTAStat::getClk());
+    DOTIMESTAT(double queryStart = PTAStat::getClk(true));
     bool mhp=mayHappenInParallelCache(i1,i2);
-    DOTIMESTAT(double queryEnd = PTAStat::getClk());
+    DOTIMESTAT(double queryEnd = PTAStat::getClk(true));
     DOTIMESTAT(interleavingQueriesTime += (queryEnd - queryStart) / TIMEINTERVAL);
 
     return mhp;

package/lib/SVF-FE/LLVMModule.cpp

@@ -83,6 +83,8 @@ SVFModule* LLVMModuleSet::buildSVFModule(Module &mod)
 
 SVFModule* LLVMModuleSet::buildSVFModule(const std::vector<std::string> &moduleNameVec)
 {
+    double startTime = SVFStat::getClk(true);
+
     assert(llvmModuleSet && "LLVM Module set needs to be created!");
 
     loadModules(moduleNameVec);
@@ -94,6 +96,9 @@ SVFModule* LLVMModuleSet::buildSVFModule(const std::vector<std::string> &moduleN
 
     build();
 
+    double endTime = SVFStat::getClk(true);
+    SVFStat::timeOfBuildingLLVMModule = (endTime - startTime)/TIMEINTERVAL;
+
     return svfModule;
 }
 

package/lib/SVF-FE/SVFIRBuilder.cpp

@@ -49,6 +49,7 @@ using namespace LLVMUtil;
  */
 SVFIR* SVFIRBuilder::build(SVFModule* svfModule)
 {
+    double startTime = SVFStat::getClk(true);
 
     // We read SVFIR from a user-defined txt instead of parsing SVFIR from LLVM IR
     if (SVFModule::pagReadFromTXT())
@@ -141,6 +142,10 @@ SVFIR* SVFIRBuilder::build(SVFModule* svfModule)
         LLVMLoopAnalysis loopAnalysis;
         loopAnalysis.build(pag->getICFG());
     }
+
+    double endTime = SVFStat::getClk(true);
+    SVFStat::timeOfBuildingSVFIR = (endTime - startTime)/TIMEINTERVAL;
+
     return pag;
 }
 

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,186 +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();
-    // REFACTOR-TODO bitcastInstStat();
-    branchStat();
-
-    printStat("General Stats");
-
+    PTNumStatMap["LocalVarInRecur"] = localVarInRecursion.count();
 }
 
 void PTAStat::callgraphStat()
@@ -265,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/SVFModule.cpp

@@ -24,11 +24,13 @@
 #include "Util/SVFModule.h"
 #include "SVF-FE/SymbolTableBuilder.h"
 #include "Util/SVFUtil.h"
+#include "Util/SVFStat.h"
 
 using namespace SVF;
 
 void SVFModule::buildSymbolTableInfo()
 {
+    double startTime = SVFStat::getClk(true);
     if (!pagReadFromTXT())
     {
         /// building symbol table
@@ -37,4 +39,6 @@ void SVFModule::buildSymbolTableInfo()
         SymbolTableBuilder builder(symInfo);
         builder.buildMemModel(this);
     }
+    double endTime = SVFStat::getClk(true);
+    SVFStat::timeOfBuildingSymbolTable = (endTime - startTime)/TIMEINTERVAL;
 }