From 1eeba8d6966aff2e7cf82c7a8f22596f5cc2e912 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 17 Feb 2025 05:07:48 +1100 Subject: [PATCH 01/19] - add callGraph edges & nodes to graoh db [tested] - add ICFG edges & nodes to graoh db [tested] add options update callgraph & icfg insert method addSVFTypeNode2db[tested] add struInfo2db [tested] fix ICFGNode err [tested] update SVFFunctionType (add params_types_vec to the node) - add PAGNode & PAGEdge to db [tested] - fixed cross join gql [tested] update bbGraph Insertion [tested] update bb insertion [tested] update bbEdge insertion [tested] --- CMakeLists.txt | 8 +- svf-llvm/CMakeLists.txt | 4 +- svf-llvm/include/SVF-LLVM/SVFIRBuilder.h | 4 + svf-llvm/lib/SVFIRBuilder.cpp | 33 +- svf-llvm/tools/AE/CMakeLists.txt | 2 +- svf-llvm/tools/CFL/CMakeLists.txt | 2 +- svf-llvm/tools/DDA/CMakeLists.txt | 2 +- svf-llvm/tools/Example/CMakeLists.txt | 2 +- svf-llvm/tools/LLVM2SVF/CMakeLists.txt | 2 +- svf-llvm/tools/MTA/CMakeLists.txt | 2 +- svf-llvm/tools/SABER/CMakeLists.txt | 2 +- svf-llvm/tools/WPA/CMakeLists.txt | 2 +- svf/include/Graphs/BasicBlockG.h | 13 +- .../Graphs/DBSchema/BasicBlockEdgeSchema.json | 10 + .../Graphs/DBSchema/BasicBlockNodeSchema.json | 41 + .../Graphs/DBSchema/CallGraphEdgeSchema.json | 35 + .../Graphs/DBSchema/CallGraphNodeSchema.json | 29 + .../Graphs/DBSchema/ICFGEdgeSchema.json | 65 + .../Graphs/DBSchema/ICFGNodeSchema.json | 246 +++ .../Graphs/DBSchema/PAGEdgeSchema.json | 1361 ++++++++++++ .../Graphs/DBSchema/PAGNodeSchema.json | 1729 +++++++++++++++ .../Graphs/DBSchema/SVFTypeNodeSchema.json | 377 ++++ svf/include/Graphs/IRGraph.h | 1 + svf/include/SVFIR/GraphDBClient.h | 467 ++++ svf/include/SVFIR/ObjTypeInfo.h | 4 + svf/include/SVFIR/SVFStatements.h | 34 +- svf/include/SVFIR/SVFType.h | 35 + svf/include/SVFIR/SVFVariables.h | 25 + svf/include/Util/Options.h | 2 + svf/include/Util/SVFLoopAndDomInfo.h | 5 + svf/lib/SVFIR/GraphDBClient.cpp | 1946 +++++++++++++++++ svf/lib/SVFIR/SVFType.cpp | 47 +- svf/lib/Util/Options.cpp | 12 + 33 files changed, 6529 insertions(+), 20 deletions(-) create mode 100644 svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json create mode 100644 svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json create mode 100644 svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json create mode 100644 svf/include/Graphs/DBSchema/CallGraphNodeSchema.json create mode 100644 svf/include/Graphs/DBSchema/ICFGEdgeSchema.json create mode 100644 svf/include/Graphs/DBSchema/ICFGNodeSchema.json create mode 100644 svf/include/Graphs/DBSchema/PAGEdgeSchema.json create mode 100644 svf/include/Graphs/DBSchema/PAGNodeSchema.json create mode 100644 svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json create mode 100644 svf/include/SVFIR/GraphDBClient.h create mode 100644 svf/lib/SVFIR/GraphDBClient.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index f5b9dd501..b5963211b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.23) + cmake_minimum_required(VERSION 3.23) # ================================================================================= # SVF project definition @@ -278,10 +278,8 @@ if(EXISTS "${SVF_SOURCE_DIR}/Test-Suite") add_subdirectory(Test-Suite) endif() -# ================================================================================= -# SVF core definitions -# ================================================================================= - +# Add the tugraph rpc library to all targets of SVF +find_library(LGRAPH_CPP_CLIENT_LIBRARIES lgraph_client_cpp_rpc REQUIRED PATHS /usr/local/lib) add_subdirectory(svf) add_subdirectory(svf-llvm) diff --git a/svf-llvm/CMakeLists.txt b/svf-llvm/CMakeLists.txt index 66be7e4e9..c5cf344c9 100644 --- a/svf-llvm/CMakeLists.txt +++ b/svf-llvm/CMakeLists.txt @@ -125,7 +125,7 @@ endif() add_dependencies(SvfLLVM gen_extapi_ir) # Link the SVF LLVM library to the core library, the build/link flags, and the LLVM libraries -target_link_libraries(SvfLLVM PUBLIC SvfFlags SvfCore ${LLVM_LIBRARIES}) +target_link_libraries(SvfLLVM PUBLIC SvfFlags ${LGRAPH_CPP_CLIENT_LIBRARIES} SvfCore ${LLVM_LIBRARIES}) # Gather & set all of the core library's source files by globbing all .h and .cpp files (recursively) file(GLOB_RECURSE SVF_LLVM_HEADERS ${CMAKE_CURRENT_LIST_DIR}/include/*.h) @@ -158,4 +158,4 @@ install( # ================================================================================= # Tools # ================================================================================= -add_subdirectory(tools) +add_subdirectory(tools) \ No newline at end of file diff --git a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h index dc79337ff..5bc20be39 100644 --- a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h +++ b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h @@ -37,6 +37,7 @@ #include "SVF-LLVM/ICFGBuilder.h" #include "SVF-LLVM/LLVMModule.h" #include "SVF-LLVM/LLVMUtil.h" +#include "SVFIR/GraphDBClient.h" namespace SVF { @@ -211,6 +212,9 @@ class SVFIRBuilder: public llvm::InstVisitor /// connect PAG edges based on callgraph void updateCallGraph(CallGraph* callgraph); + void insertCallGraph2db(const CallGraph* callgraph); + void insertICFG2db(const ICFG* icfg); + protected: /// Handle globals including (global variable and functions) //@{ diff --git a/svf-llvm/lib/SVFIRBuilder.cpp b/svf-llvm/lib/SVFIRBuilder.cpp index 9168faed1..4c72e0308 100644 --- a/svf-llvm/lib/SVFIRBuilder.cpp +++ b/svf-llvm/lib/SVFIRBuilder.cpp @@ -47,6 +47,7 @@ using namespace SVF; using namespace SVFUtil; using namespace LLVMUtil; +lgraph::RpcClient* dbConnection = SVF::GraphDBClient::getInstance().getConnection(); /*! * Start building SVFIR here @@ -64,6 +65,23 @@ SVFIR* SVFIRBuilder::build() return fileBuilder.build(); } + if (Options::ReadFromDB()) + { + GraphDBClient::getInstance().readSVFTypesFromDB(dbConnection, "SVFType", pag); + GraphDBClient::getInstance().initialSVFPAGNodesFromDB(dbConnection, "PAG",pag); + GraphDBClient::getInstance().readBasicBlockGraphFromDB(dbConnection, "BasicBlockGraph"); + ICFG* icfg = GraphDBClient::getInstance().buildICFGFromDB(dbConnection, "ICFG", pag); + pag->icfg = icfg; + CallGraph* callGraph = GraphDBClient::getInstance().buildCallGraphFromDB(dbConnection,"CallGraph",pag); + CHGraph* chg = new CHGraph(); + pag->setCHG(chg); + pag->callGraph = callGraph; + GraphDBClient::getInstance().updatePAGNodesFromDB(dbConnection, "PAG", pag); + GraphDBClient::getInstance().loadSVFPAGEdgesFromDB(dbConnection, "PAG",pag); + GraphDBClient::getInstance().parseSVFStmtsForICFGNodeFromDBResult(pag); + return pag; + } + // If the SVFIR has been built before, then we return the unique SVFIR of the program if(pag->getNodeNumAfterPAGBuild() > 1) return pag; @@ -159,6 +177,15 @@ SVFIR* SVFIRBuilder::build() pag->setNodeNumAfterPAGBuild(pag->getTotalNodeNum()); + if (Options::Write2DB()) { + std::string dbname = "SVFType"; + GraphDBClient::getInstance().insertSVFTypeNodeSet2db(&pag->getSVFTypes(), &pag->getStInfos(), dbname); + GraphDBClient::getInstance().insertPAG2db(pag); + GraphDBClient::getInstance().insertICFG2db(pag->icfg); + GraphDBClient::getInstance().insertCHG2db(chg); + GraphDBClient::getInstance().insertCallGraph2db(pag->callGraph); + } + // dump SVFIR if (Options::PAGDotGraph()) pag->dump("svfir_initial"); @@ -1597,7 +1624,9 @@ const Value* SVFIRBuilder::getBaseValueForExtArg(const Value* V) void SVFIRBuilder::handleIndCall(CallBase* cs) { const CallICFGNode* cbn = llvmModuleSet()->getCallICFGNode(cs); - pag->addIndirectCallsites(cbn,llvmModuleSet()->getValueNode(cs->getCalledOperand())); + NodeID indFunPtrId = llvmModuleSet()->getValueNode(cs->getCalledOperand()); + const_cast(cbn)->setIndFunPtr(pag->getGNode(indFunPtrId)); + pag->addIndirectCallsites(cbn,indFunPtrId); } void SVFIRBuilder::updateCallGraph(CallGraph* callgraph) @@ -1818,4 +1847,4 @@ AccessPath SVFIRBuilder::getAccessPathFromBaseNode(NodeID nodeId) return AccessPath(0); else return gepEdge->getAccessPath(); -} +} \ No newline at end of file diff --git a/svf-llvm/tools/AE/CMakeLists.txt b/svf-llvm/tools/AE/CMakeLists.txt index 883e4d7a2..1dd0dcf5f 100644 --- a/svf-llvm/tools/AE/CMakeLists.txt +++ b/svf-llvm/tools/AE/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(ae ae.cpp) +add_llvm_executable(ae ae.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/CFL/CMakeLists.txt b/svf-llvm/tools/CFL/CMakeLists.txt index 28bf83bab..bcd4567c3 100644 --- a/svf-llvm/tools/CFL/CMakeLists.txt +++ b/svf-llvm/tools/CFL/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(cfl cfl.cpp) +add_llvm_executable(cfl cfl.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/DDA/CMakeLists.txt b/svf-llvm/tools/DDA/CMakeLists.txt index 06ca6c2bd..499f7395b 100644 --- a/svf-llvm/tools/DDA/CMakeLists.txt +++ b/svf-llvm/tools/DDA/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(dvf dda.cpp) +add_llvm_executable(dvf dda.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/Example/CMakeLists.txt b/svf-llvm/tools/Example/CMakeLists.txt index 6e5b3e538..ee114a71d 100644 --- a/svf-llvm/tools/Example/CMakeLists.txt +++ b/svf-llvm/tools/Example/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(svf-ex svf-ex.cpp) +add_llvm_executable(svf-ex svf-ex.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/LLVM2SVF/CMakeLists.txt b/svf-llvm/tools/LLVM2SVF/CMakeLists.txt index c853b19e1..21ad95955 100644 --- a/svf-llvm/tools/LLVM2SVF/CMakeLists.txt +++ b/svf-llvm/tools/LLVM2SVF/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(llvm2svf llvm2svf.cpp) +add_llvm_executable(llvm2svf llvm2svf.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/MTA/CMakeLists.txt b/svf-llvm/tools/MTA/CMakeLists.txt index 0810407bf..24a8c673b 100644 --- a/svf-llvm/tools/MTA/CMakeLists.txt +++ b/svf-llvm/tools/MTA/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(mta mta.cpp) +add_llvm_executable(mta mta.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/SABER/CMakeLists.txt b/svf-llvm/tools/SABER/CMakeLists.txt index 3bae7a7f4..76260fecf 100644 --- a/svf-llvm/tools/SABER/CMakeLists.txt +++ b/svf-llvm/tools/SABER/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(saber saber.cpp) +add_llvm_executable(saber saber.cpp) \ No newline at end of file diff --git a/svf-llvm/tools/WPA/CMakeLists.txt b/svf-llvm/tools/WPA/CMakeLists.txt index 2b30226a9..af777ab1b 100644 --- a/svf-llvm/tools/WPA/CMakeLists.txt +++ b/svf-llvm/tools/WPA/CMakeLists.txt @@ -3,4 +3,4 @@ set(THREADS_PREFER_PTHREAD_FLAG ON) add_llvm_executable(wpa wpa.cpp) find_package(Threads REQUIRED) -target_link_libraries(wpa PUBLIC Threads::Threads) +target_link_libraries(wpa PUBLIC ${LGRAPH_CPP_CLIENT_LIBRARIES} Threads::Threads) \ No newline at end of file diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index 495c3f335..2eaa40394 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -282,6 +282,16 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy const std::string toString() const; + const std::vector getSuccBBs() const + { + return succBBs; + } + + const std::vector getPredBBs() const + { + return predBBs; + } + }; @@ -293,11 +303,12 @@ class BasicBlockGraph: public GenericBasicBlockGraphTy NodeID id{0}; public: /// Constructor - BasicBlockGraph() + BasicBlockGraph(): GenericBasicBlockGraphTy() { } + SVFBasicBlock* addBasicBlock(const std::string& bbname) { id++; diff --git a/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json b/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json new file mode 100644 index 000000000..06794f06d --- /dev/null +++ b/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json @@ -0,0 +1,10 @@ +{ + "schema": [ + { + "label":"BasicBlockEdge", + "type":"EDGE", + "properties" : [] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json b/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json new file mode 100644 index 000000000..4c8a32ad2 --- /dev/null +++ b/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json @@ -0,0 +1,41 @@ +{ + "schema": [ + { + "label" : "SVFBasicBlock", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"sscc_bb_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"pred_bb_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"all_icfg_nodes_ids", + "type":"STRING", + "optional":false, + "index":false + } + ] + } + ] +} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json b/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json new file mode 100644 index 000000000..e14624e2c --- /dev/null +++ b/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json @@ -0,0 +1,35 @@ +{ + "schema": [ + { + "label":"CallGraphEdge", + "type":"EDGE", + "properties" : [ + { + "name" : "csid", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"direct_call_set", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"indirect_call_set", + "type":"STRING", + "optional":false, + "index":false + } + ] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json new file mode 100644 index 000000000..d4e89a83a --- /dev/null +++ b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json @@ -0,0 +1,29 @@ +{ + "schema": [ + { + "label" : "CallGraphNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_reachable_from_prog_entry", + "type":"BOOL", + "optional":false, + "index":false + } + ] + } + ] +} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json b/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json new file mode 100644 index 000000000..146bd705e --- /dev/null +++ b/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json @@ -0,0 +1,65 @@ +{ + "schema": [ + { + "label" : "IntraCFGEdge", + "type" : "EDGE", + "properties" : [ + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "condition_var_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name" : "branch_condition_val", + "type":"INT64", + "optional":true, + "index":false + } + ] + }, + { + "label" : "CallCFGEdge", + "type" : "EDGE", + "properties" : [ + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"call_pe_ids", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "RetCFGEdge", + "type" : "EDGE", + "properties" : [ + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"ret_pe_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json new file mode 100644 index 000000000..07ec0bff1 --- /dev/null +++ b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json @@ -0,0 +1,246 @@ +{ + "schema": [ + { + "label" : "GlobalICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "IntraICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_return", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "InterICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "FunEntryICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"fp_nodes", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "FunExitICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"formal_ret_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "CallICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"ret_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type", + "type":"STRING", + "index":false, + "optional":false + }, + { + "name":"ap_nodes", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"called_fun_obj_var_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"is_vararg", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"is_vir_call_inst", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"vtab_ptr_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"virtual_fun_idx", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"fun_name_of_v_call", + "type":"STRING", + "optional":true, + "index":false + } + ] + }, + { + "label" : "RetICFGNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"actual_ret_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"call_block_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json new file mode 100644 index 000000000..4a0e5a142 --- /dev/null +++ b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json @@ -0,0 +1,1361 @@ +{ + "schema": [ + { + "label" : "SVFStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "AssignStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "AddrStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"arr_size", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "CopyStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"copy_kind", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "StoreStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "LoadStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "GepStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"variant_field", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"ap_fld_idx", + "type":"INT64", + "optional":true, + "index":false + }, + { + "name":"ap_gep_pointee_type_name", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"ap_idx_operand_pairs", + "type":"STRING", + "optional":true, + "index":false + } + ] + }, + { + "label" : "CallPE", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"call_icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"fun_entry_icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "RetPE", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"call_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"fun_exit_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "MultiOpndStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_var_node_ids", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "PhiStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_var_node_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"op_icfg_nodes_ids", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SelectStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_var_node_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"condition_svf_var_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "CmpStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_var_node_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"predicate", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "BinaryOPStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_var_node_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"op_code", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "UnaryOPStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"op_code", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "BranchStmt", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"condition_svf_var_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"br_inst_svf_var_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"successors", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "TDForkPE", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"call_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"fun_entry_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "RetPETDJoinPE", + "type" : "EDGE", + "properties" : [ + { + "name" : "edge_id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name" : "kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "svf_var_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"inst2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"var2_label_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"call_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"store_edge_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"multi_opnd_label_counter", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"call_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"fun_exit_icfg_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/PAGNodeSchema.json b/svf/include/Graphs/DBSchema/PAGNodeSchema.json new file mode 100644 index 000000000..414431e2d --- /dev/null +++ b/svf/include/Graphs/DBSchema/PAGNodeSchema.json @@ -0,0 +1,1729 @@ +{ + "schema": [ + { + "label" : "SVFVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ArgValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"cg_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"arg_no", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "GepValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"base_val_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"gep_val_svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"ap_fld_idx", + "type":"INT64", + "optional":false, + "index":false + }, + { + "name":"ap_gep_pointee_type_name", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"ap_idx_operand_pairs", + "type":"STRING", + "optional":true, + "index":false + } + ] + }, + { + "label" : "BaseObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "GepObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"base_obj_var_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"app_offset", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "HeapObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "StackObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "FunObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"is_decl", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"intrinsic", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"is_addr_taken", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"is_uncalled", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"is_not_ret", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"sup_var_arg", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"fun_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"real_def_fun_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"exit_bb_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"all_args_node_ids", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"reachable_bbs", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"dt_bbs_map", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"pdt_bbs_map", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"df_bbs_map", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"bb2_loop_map", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name": "bb2_p_dom_level", + "type": "STRING", + "optional": false, + "index": false + }, + { + "name":"bb2_pi_dom", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, { + "label" : "FunValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"fun_obj_var_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "GlobalValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstAggValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstDataValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "BlackHoleValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstFPValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"dval", + "type":"DOUBLE", + "optional":false, + "index":false + } + ] + }, + { + "label" : "ConstIntValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"zval", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"sval", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "ConstNullPtrValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "GlobalObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstAggObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstDataObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "ConstFPObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"dval", + "type":"FLOAT", + "optional":false, + "index":false + } + ] + }, + { + "label" : "ConstIntObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"zval", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"sval", + "type":"INT64", + "optional":false, + "index":false + } + ] + }, + { + "label" : "ConstNullPtrObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "RetValPN", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"call_graph_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "VarArgValPN", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"call_graph_node_id", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "DummyValVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + } + ] + }, + { + "label" : "DummyObjVar", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"svf_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"in_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"out_edge_kind_to_set_map", + "type":"STRING", + "optional":true, + "index":false + }, + { + "name":"icfg_node_id", + "type":"INT32", + "optional":true, + "index":false + }, + { + "name":"obj_type_info_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_flags", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_max_offset_limit", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_elem_num", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"obj_type_info_byte_size", + "type":"INT32", + "optional":true, + "index":false + } + ] + } + ] +} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json new file mode 100644 index 000000000..62c392add --- /dev/null +++ b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json @@ -0,0 +1,377 @@ +{ + "schema": [ + { + "label" : "SVFPointerTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SVFIntegerTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"single_and_width", + "type":"INT32", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SVFFunctionTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"ret_ty_node_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"params_types_vec", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SVFStructTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"stinfo_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"struct_name", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SVFArrayTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"stinfo_node_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"num_of_element", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"type_of_element_node_type_name", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "SVFOtherTypeNode", + "type" : "VERTEX", + "primary" : "type_name", + "properties" : [ + { + "name" : "type_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name":"svf_i8_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"svf_ptr_type_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"kind", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"is_single_val_ty", + "type":"BOOL", + "optional":false, + "index":false + }, + { + "name":"byte_size", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"repr", + "type":"STRING", + "optional":false, + "index":false + } + ] + }, + { + "label" : "StInfoNode", + "type" : "VERTEX", + "primary" : "id", + "properties" : [ + { + "name" : "id", + "type":"INT32", + "optional":false, + "index":true + }, + { + "name":"fld_idx_vec", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"elem_idx_vec", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"fld_idx_2_type_map", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"finfo_types", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"stride", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"num_of_flatten_elements", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"num_of_flatten_fields", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"flatten_element_types", + "type":"STRING", + "optional":false, + "index":false + } + ] + } + ] +} \ No newline at end of file diff --git a/svf/include/Graphs/IRGraph.h b/svf/include/Graphs/IRGraph.h index 6fd878a6f..08c8f352d 100644 --- a/svf/include/Graphs/IRGraph.h +++ b/svf/include/Graphs/IRGraph.h @@ -360,6 +360,7 @@ class IRGraph : public GenericGraph inline void addStInfo(StInfo* stInfo) { + stInfo->setStinfoId(stInfos.size()); stInfos.insert(stInfo); } diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h new file mode 100644 index 000000000..103df8f76 --- /dev/null +++ b/svf/include/SVFIR/GraphDBClient.h @@ -0,0 +1,467 @@ +#ifndef INCLUDE_GRAPHDBCLIENT_H_ +#define INCLUDE_GRAPHDBCLIENT_H_ +#include "Graphs/CallGraph.h" +#include "Graphs/ICFGEdge.h" +#include "Graphs/ICFGNode.h" +#include "SVFIR/SVFType.h" +#include "SVFIR/SVFIR.h" +#include "SVFIR/SVFStatements.h" +#include "Util/SVFUtil.h" +#include "lgraph/lgraph_rpc_client.h" +#include +#include + +namespace SVF +{ +class RpcClient; +class ICFGEdge; +class ICFGNode; +class CallGraphEdge; +class CallGraphNode; +class SVFType; +class StInfo; +class SVFIR; +class SVFVar; +class SVFStmt; +class SVFBasicBlock; +class BasicBlockEdge; +class BasicBlockGraph; +class GraphDBClient +{ +private: + lgraph::RpcClient* connection; + + GraphDBClient() + { + const char* url = "127.0.0.1:9090"; + connection = new lgraph::RpcClient(url, "admin", "qazwsx123"); + } + + ~GraphDBClient() + { + if (connection != nullptr) + { + connection = nullptr; + } + } + +public: + static GraphDBClient& getInstance() + { + static GraphDBClient instance; + return instance; + } + + GraphDBClient(const GraphDBClient&) = delete; + GraphDBClient& operator=(const GraphDBClient&) = delete; + + lgraph::RpcClient* getConnection() + { + return connection; + } + + void processNode(lgraph::RpcClient* connection, ICFGNode* node, const std::string& dbname); + bool loadSchema(lgraph::RpcClient* connection, const std::string& filepath, + const std::string& dbname); + bool createSubGraph(lgraph::RpcClient* connection, const std::string& graphname); + bool addCallGraphNode2db(lgraph::RpcClient* connection, + const CallGraphNode* node, + const std::string& dbname); + bool addCallGraphEdge2db(lgraph::RpcClient* connection, + const CallGraphEdge* edge, const std::string& dbname); + bool addICFGNode2db(lgraph::RpcClient* connection, const ICFGNode* node, + const std::string& dbname); + bool addICFGEdge2db(lgraph::RpcClient* connection, const ICFGEdge* edge, + const std::string& dbname); + /// pasre the directcallsIds/indirectcallsIds string to vector + std::vector stringToIds(const std::string& str); + + template + std::string extractNodesIds(const Container& nodes) + { + if (nodes.empty()) + { + return ""; + } + std::ostringstream nodesIds; + auto it = nodes.begin(); + + nodesIds << (*it)->getId(); + ++it; + + for (; it != nodes.end(); ++it) + { + nodesIds << "," << (*it)->getId(); + } + + return nodesIds.str(); + } + + template + std::string extractEdgesIds(const Container& edges) + { + if (edges.empty()) + { + return ""; + } + std::ostringstream edgesIds; + auto it = edges.begin(); + + edgesIds << (*it)->getEdgeID(); + ++it; + + for (; it != edges.end(); ++it) + { + edgesIds << "," << (*it)->getEdgeID(); + } + + return edgesIds.str(); + } + + template + std::string extractIdxs(const Container& idxVec) + { + if (idxVec.empty()) + { + return ""; + } + std::ostringstream idxVecStr; + auto it = idxVec.begin(); + + idxVecStr << *it; + ++it; + + for (; it != idxVec.end(); ++it) + { + idxVecStr << "," << *it; + } + + return idxVecStr.str(); + } + + template + std::string extractSVFTypes(const Container& types) + { + if (types.empty()) + { + return ""; + } + std::ostringstream typesStr; + auto it = types.begin(); + + typesStr << (*it)->toString(); + ++it; + + for (; it != types.end(); ++it) + { + typesStr << "," << (*it)->toString(); + } + + return typesStr.str(); + } + + template + std::string extractFldIdx2TypeMap(const MapType& fldIdx2TypeMap) + { + if (fldIdx2TypeMap.empty()) + { + return ""; + } + std::ostringstream mapStr; + auto it = fldIdx2TypeMap.begin(); + + mapStr << it->first << ":" << it->second->toString(); + ++it; + + for (; it != fldIdx2TypeMap.end(); ++it) + { + mapStr << "," << it->first << ":" << it->second->toString(); + } + + return mapStr.str(); + } + + template + std::string extractLabelMap2String(const LabelMapType& labelMap) + { + if (labelMap->empty()) + { + return ""; + } + std::ostringstream mapStr; + + for (auto it = labelMap->begin(); it != labelMap->end(); ++it) + { + if (it != labelMap->begin()) + { + mapStr << ","; + } + mapStr << (it->first ? std::to_string(it->first->getId()) : "NULL") + << ":" << std::to_string(it->second); + } + + return mapStr.str(); + } + + template + std::string extractBBsMapWithSet2String(const BBsMapWithSetType& bbsMap) + { + if (bbsMap->empty()) + { + return ""; + } + std::ostringstream mapStr; + auto it = bbsMap->begin(); + + for (; it != bbsMap->end(); ++it) + { + mapStr << "[" << it->first->getId() << ":"; + mapStr << extractNodesIds(it->second); + mapStr << "]"; + } + + return mapStr.str(); + } + + template + std::string extractBBsMap2String(const BBsMapType& bbsMap) + { + if (bbsMap->empty()) + { + return ""; + } + std::ostringstream mapStr; + for (const auto& pair : *bbsMap) { + if (mapStr.tellp() != std::streampos(0)) { + mapStr << ","; + } + if (pair.first != nullptr && pair.second != nullptr) { + mapStr << pair.first->getId() << ":" << pair.second->getId(); + } + else if (pair.first == nullptr) { + mapStr << "NULL:" << pair.second->getId(); + } + else if (pair.second == nullptr) { + mapStr << pair.first->getId() << ":NULL"; + } + } + return mapStr.str(); + } + + template + std::string pagEdgeToSetMapTyToString(const MapType& map) + { + if (map.empty()) + { + return ""; + } + + std::ostringstream oss; + + for (auto it = map.begin(); it != map.end(); ++it) + { + oss << "[" << it->first << ":"; + const SVFStmt::SVFStmtSetTy& set = it->second; + for (auto setIt = set.begin(); setIt != set.end(); ++setIt) + { + if (setIt != set.begin()) + { + oss << ","; + } + oss << (*setIt)->getEdgeID(); + } + oss << "]"; + + if (std::next(it) != map.end()) + { + oss << ","; + } + } + + return oss.str(); + } + + /// Convert IdxOperandPairs to string + std::string IdxOperandPairsToString(const AccessPath::IdxOperandPairs* idxOperandPairs) const + { + if (idxOperandPairs->empty()) + { + return ""; + } + + std::ostringstream oss; + oss << "["; + for (auto it = idxOperandPairs->begin(); it != idxOperandPairs->end(); ++it) + { + if (it != idxOperandPairs->begin()) + { + oss << ", "; + } + oss << IdxOperandPairToString(*it); + } + oss << "]"; + return oss.str(); + } + + std::string IdxOperandPairToString(const AccessPath::IdxOperandPair& pair) const + { + std::ostringstream oss; + if (nullptr != pair.first && nullptr != pair.second) + { + oss << "{" << pair.first->getId() << ", " << pair.second->toString() << "}"; + return oss.str(); + } else if (nullptr == pair.second) + { + oss << "{" << pair.first->getId() << ", NULL}"; + } + return ""; + } + + std::string extractSuccessorsPairSet2String(const BranchStmt::SuccAndCondPairVec* vec) + { + std::ostringstream oss; + for (auto it = vec->begin(); it != vec->end(); ++it) + { + if (it != vec->begin()) + { + oss << ","; + } + oss << (*it).first->getId()<<":"<< std::to_string((*it).second); + } + + return oss.str(); + } + + /// parse and extract the directcallsIds/indirectcallsIds vector + + /// parse ICFGNodes & generate the insert statement for ICFGNodes + std::string getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node); + + std::string getIntraICFGNodeInsertStmt(const IntraICFGNode* node); + + std::string getInterICFGNodeInsertStmt(const InterICFGNode* node); + + std::string getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node); + + std::string getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node); + + std::string getCallICFGNodeInsertStmt(const CallICFGNode* node); + + std::string getRetICFGNodeInsertStmt(const RetICFGNode* node); + + std::string getIntraCFGEdgeStmt(const IntraCFGEdge* edge); + + std::string getCallCFGEdgeStmt(const CallCFGEdge* edge); + + std::string getRetCFGEdgeStmt(const RetCFGEdge* edge); + + std::string getICFGNodeKindString(const ICFGNode* node); + + void insertICFG2db(const ICFG* icfg); + + void insertCallGraph2db(const CallGraph* callGraph); + + void insertPAG2db(const SVFIR* pag); + + void insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph); + + void insertSVFTypeNodeSet2db(const Set* types,const Set* stInfos, std::string& dbname); + + std::string getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node); + + std::string getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node); + + std::string getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node); + + std::string getSVFSturctTypeNodeInsertStmt(const SVFStructType* node); + + std::string getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node); + + std::string getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node); + + std::string getStInfoNodeInsertStmt(const StInfo* node); + + /// parse and generate the node insert statement for valvar nodes + std::string getSVFVarNodeFieldsStmt(const SVFVar* node); + std::string getValVarNodeFieldsStmt(const ValVar* node); + std::string getValVarNodeInsertStmt(const ValVar* node); + std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node); + /// ConstDataValVar and its sub-class + std::string getConstDataValVarNodeInsertStmt(const ConstDataValVar* node); + std::string getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node); + std::string getConstFPValVarNodeInsertStmt(const ConstFPValVar* node); + std::string getConstIntValVarNodeInsertStmt(const ConstIntValVar* node); + std::string getConstNullPtrValVarNodeInsertStmt(const ConstNullPtrValVar* node); + // parse and generate the node insert statement for valvar sub-class + std::string getRetValPNNodeInsertStmt(const RetValPN* node); + std::string getVarArgValPNNodeInsertStmt(const VarArgValPN* node); + std::string getDummyValVarNodeInsertStmt(const DummyValVar* node); + std::string getConstAggValVarNodeInsertStmt(const ConstAggValVar* node); + std::string getGlobalValVarNodeInsertStmt(const GlobalValVar* node); + std::string getFunValVarNodeInsertStmt(const FunValVar* node); + std::string getGepValVarNodeInsertStmt(const GepValVar* node); + std::string getArgValVarNodeInsertStmt(const ArgValVar* node); + + /// parse and generate the node insert statement for objvar nodes + std::string getObjVarNodeFieldsStmt(const ObjVar* node); + std::string getObjVarNodeInsertStmt(const ObjVar* node); + std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* node); + std::string getBaseObjNodeInsertStmt(const BaseObjVar* node); + std::string getGepObjVarNodeInsertStmt(const GepObjVar* node); + + /// parse and generate the node insert statement for baseObjVar sub-class + std::string getHeapObjVarNodeInsertStmt(const HeapObjVar* node); + std::string getStackObjVarNodeInsertStmt(const StackObjVar* node); + std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node); + std::string getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node); + std::string getConstNullPtrObjVarNodeInsertStmt(const ConstNullPtrObjVar* node); + std::string getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node); + std::string getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node); + std::string getDummyObjVarNodeInsertStmt(const DummyObjVar* node); + std::string getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node); + std::string getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node); + std::string getFunObjVarNodeInsertStmt(const FunObjVar* node); + + + + /// parse and generate the edge insert statement for SVFStmt + std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge); + std::string generateSVFStmtEdgeInsertStmt(const SVFStmt* edge); + /// parse and generate the edge insert statement for AssignStmt & its sub-class + std::string generateAssignStmtFieldsStmt(const AssignStmt* edge); + std::string generateAssignStmtEdgeInsertStmt(const AssignStmt* edge); + std::string generateAddrStmtEdgeInsertStmt(const AddrStmt* edge); + std::string generateCopyStmtEdgeInsertStmt(const CopyStmt* edge); + std::string generateStoreStmtEdgeInsertStmt(const StoreStmt* edge); + std::string generateLoadStmtEdgeInsertStmt(const LoadStmt* edge); + std::string generateGepStmtEdgeInsertStmt(const GepStmt* edge); + std::string generateCallPEEdgeInsertStmt(const CallPE* edge); + std::string generateRetPEEdgeInsertStmt(const RetPE* edge); + std::string generateTDForkPEEdgeInsertStmt(const TDForkPE* edge); + std::string generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge); + /// parse and generate the edge insert statement for MultiOpndStmt & its sub-class + std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge); + std::string generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge); + std::string generatePhiStmtEdgeInsertStmt(const PhiStmt* edge); + std::string generateSelectStmtEndgeInsertStmt(const SelectStmt* edge); + std::string generateCmpStmtEdgeInsertStmt(const CmpStmt* edge); + std::string generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge); + + std::string genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge); + std::string generateBranchStmtEdgeInsertStmt(const BranchStmt* edge); + + + std::string getPAGNodeInsertStmt(const SVFVar* node); + void insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, const std::string& dbname); + void insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* node, const std::string& dbname); + void insertBBNode2db(lgraph::RpcClient* connection, const SVFBasicBlock* node, const std::string& dbname); + void insertBBEdge2db(lgraph::RpcClient* connection, const BasicBlockEdge* node, const std::string& dbname); + std::string getBBNodeInsertStmt (const SVFBasicBlock* node); + std::string getBBEdgeInsertStmt(const BasicBlockEdge* edge); + std::string getPAGEdgeInsertStmt(const SVFStmt* edge); + std::string getPAGNodeKindString(const SVFVar* node); +}; + +} // namespace SVF + +#endif \ No newline at end of file diff --git a/svf/include/SVFIR/ObjTypeInfo.h b/svf/include/SVFIR/ObjTypeInfo.h index fc960d56a..0138decee 100644 --- a/svf/include/SVFIR/ObjTypeInfo.h +++ b/svf/include/SVFIR/ObjTypeInfo.h @@ -148,6 +148,10 @@ class ObjTypeInfo { flags |= mask; } + inline u32_t getFlag() const + { + return flags; + } inline bool hasFlag(MEMTYPE mask) { return (flags & mask) == mask; diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index 73d66d6d0..c26e1526f 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -90,7 +90,7 @@ class SVFStmt : public GenericPAGEdgeTy } public: - static u32_t totalEdgeNum; ///< Total edge number + // static u32_t totalEdgeNum; ///< Total edge number /// Constructor SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real = true); @@ -222,6 +222,33 @@ class SVFStmt : public GenericPAGEdgeTy static u64_t callEdgeLabelCounter; ///< Call site Instruction counter static u64_t storeEdgeLabelCounter; ///< Store Instruction counter static u64_t multiOpndLabelCounter; ///< MultiOpndStmt counter + +public: + static inline const Inst2LabelMap* getInst2LabelMap() + { + return &inst2LabelMap; + } + + static inline const Var2LabelMap* getVar2LabelMap() + { + return &var2LabelMap; + } + + static inline const u64_t* getCallEdgeLabelCounter() + { + return &callEdgeLabelCounter; + } + + static inline const u64_t* getStoreEdgeLabelCounter() + { + return &storeEdgeLabelCounter; + } + + static inline const u64_t* getMultiOpndLabelCounter() + { + return &multiOpndLabelCounter; + } + }; /* @@ -816,6 +843,11 @@ class PhiStmt: public MultiOpndStmt "Numbers of operands and their ICFGNodes are not consistent?"); } + inline const OpICFGNodeVec* getOpICFGNodeVec() const + { + return &opICFGNodes; + } + /// Return the corresponding ICFGNode of this operand inline const ICFGNode* getOpICFGNode(u32_t op_idx) const { diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index d75c82743..34794ff5e 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -47,6 +47,7 @@ class StInfo { private: + u32_t StInfoId; /// flattened field indices of a struct (ignoring arrays) std::vector fldIdxVec; /// flattened element indices including structs and arrays by considering @@ -121,6 +122,15 @@ class StInfo { return finfo; } + inline const u32_t getStinfoId() const + { + return StInfoId; + } + + inline const Map& getFldIdx2TypeMap() const + { + return fldIdx2TypeMap; + } //@} /// Add field index and element index and their corresponding type @@ -133,6 +143,11 @@ class StInfo numOfFlattenElements = ne; } + inline void setStinfoId(u32_t id) + { + StInfoId = id; + } + /// Return number of elements after flattening (including array elements) inline u32_t getNumOfFlattenElements() const { @@ -308,6 +323,11 @@ class SVFIntegerType : public SVFType signAndWidth = sw; } + short getSignAndWidth() const + { + return signAndWidth; + } + bool isSigned() const { return signAndWidth < 0; @@ -376,6 +396,12 @@ class SVFStructType : public SVFType { return name; } + + const std::string& getName() const + { + return name; + } + void setName(const std::string& structName) { name = structName; @@ -426,6 +452,11 @@ class SVFArrayType : public SVFType numOfElement = elemNum; } + const unsigned getNumOfElement() const + { + return numOfElement; + } + }; @@ -447,6 +478,10 @@ class SVFOtherType : public SVFType { return repr; } + const std::string& getRepr() const + { + return repr; + } void setRepr(std::string&& r) { diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index bc5e2d1ca..1429377cc 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -107,6 +107,16 @@ class SVFVar : public GenericPAGNodeTy return nullptr; } + inline const SVFStmt::KindToSVFStmtMapTy& getInEdgeKindToSetMap() const + { + return InEdgeKindToSetMap; + } + + inline const SVFStmt::KindToSVFStmtMapTy& getOutEdgeKindToSetMap() const + { + return OutEdgeKindToSetMap; + } + /// Edge accessors and checkers //@{ inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind) @@ -439,6 +449,11 @@ class GepValVar: public ValVar { return node->getNodeKind() == SVFVar::GepValNode; } + + inline const AccessPath& getAccessPath() const + { + return ap; + } //@} /// Constructor @@ -544,6 +559,11 @@ class BaseObjVar : public ObjVar return this; } + inline const ObjTypeInfo* getTypeInfo() const + { + return typeInfo; + } + /// Get the ICFGNode related to the creation of this object inline const ICFGNode* getICFGNode() const { @@ -1147,6 +1167,11 @@ class FunObjVar : public BaseObjVar return allArgs[idx]; } + inline const std::vector &getArgs() const + { + return allArgs; + } + inline const SVFBasicBlock* front() const { return getEntryBlock(); diff --git a/svf/include/Util/Options.h b/svf/include/Util/Options.h index 0fa17910d..6b711975c 100644 --- a/svf/include/Util/Options.h +++ b/svf/include/Util/Options.h @@ -212,6 +212,8 @@ class Options static const Option DiffPts; static Option DetectPWC; static const Option VtableInSVFIR; + static const Option Write2DB; + static const Option ReadFromDB; // WPAPass.cpp static const Option ExtAPIPath; diff --git a/svf/include/Util/SVFLoopAndDomInfo.h b/svf/include/Util/SVFLoopAndDomInfo.h index 559947493..70959be6f 100644 --- a/svf/include/Util/SVFLoopAndDomInfo.h +++ b/svf/include/Util/SVFLoopAndDomInfo.h @@ -72,6 +72,11 @@ class SVFLoopAndDomInfo return dfBBsMap; } + inline const Map& getBB2LoopMap() const + { + return bb2LoopMap; + } + inline bool hasLoopInfo(const SVFBasicBlock* bb) const { return bb2LoopMap.find(bb) != bb2LoopMap.end(); diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp new file mode 100644 index 000000000..691f1cfc2 --- /dev/null +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -0,0 +1,1946 @@ +#include "SVFIR/GraphDBClient.h" +#include "SVFIR/SVFVariables.h" + +using namespace SVF; + +bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, + const std::string& filepath, + const std::string& dbname) +{ + if (nullptr != connection) + { + SVFUtil::outs() << "load schema from file:" << filepath << "\n"; + std::string result; + bool ret = connection->ImportSchemaFromFile(result, filepath, dbname); + if (ret) + { + SVFUtil::outs() << dbname<< "schema load successfully:" << result << "\n"; + } + else + { + SVFUtil::outs() << dbname<< "schema load failed:" << result << "\n"; + } + return ret; + } + return false; +} + +// create a new graph name CallGraph in db +bool GraphDBClient::createSubGraph(lgraph::RpcClient* connection, const std::string& graphname) +{ + ///TODO: graph name should be configurable + if (nullptr != connection) + { + std::string result; + connection->CallCypher(result, "CALL dbms.graph.deleteGraph('"+graphname+"')"); + bool ret = connection->CallCypherToLeader(result, "CALL dbms.graph.createGraph('"+graphname+"')"); + if (ret) + { + SVFUtil::outs() + << "Create Graph callGraph successfully:" << result << "\n"; + } + else + { + SVFUtil::outs() + << "Failed to create Graph callGraph:" << result << "\n"; + } + } + return false; +} + +bool GraphDBClient::addICFGEdge2db(lgraph::RpcClient* connection, + const ICFGEdge* edge, + const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement; + if(SVFUtil::isa(edge)) + { + queryStatement = getIntraCFGEdgeStmt(SVFUtil::cast(edge)); + } + else if (SVFUtil::isa(edge)) + { + queryStatement = getCallCFGEdgeStmt(SVFUtil::cast(edge)); + } + else if (SVFUtil::isa(edge)) + { + queryStatement = getRetCFGEdgeStmt(SVFUtil::cast(edge)); + } + else + { + assert("unknown icfg edge type?"); + return false; + } + // SVFUtil::outs() << "ICFGEdge Query Statement:" << queryStatement << "\n"; + std::string result; + if (queryStatement.empty()) + { + return false; + } + bool ret = connection->CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "ICFG edge added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add ICFG edge to db " << dbname << " " + << result << "\n"; + } + return ret; + + } + return false; +} + +bool GraphDBClient::addICFGNode2db(lgraph::RpcClient* connection, + const ICFGNode* node, + const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement; + if(SVFUtil::isa(node)) + { + queryStatement = getGlobalICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else if (SVFUtil::isa(node)) + { + queryStatement = getIntraICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else if (SVFUtil::isa(node)) + { + queryStatement = getFunEntryICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else if (SVFUtil::isa(node)) + { + queryStatement = getFunExitICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else if (SVFUtil::isa(node)) + { + queryStatement = getCallICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else if (SVFUtil::isa(node)) + { + queryStatement = getRetICFGNodeInsertStmt(SVFUtil::cast(node)); + } + else + { + assert("unknown icfg node type?"); + return false; + } + + // SVFUtil::outs()<<"ICFGNode Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs()<< "ICFG node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add icfg node to db " << dbname << " " + << result << "\n"; + } + return ret; + } + return false; +} + +bool GraphDBClient::addCallGraphNode2db(lgraph::RpcClient* connection, + const CallGraphNode* node, + const std::string& dbname) +{ + if (nullptr != connection) + { + std::string is_reachable_str = node->isReachableFromProgEntry() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(node->getId()) + + ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + + ", is_reachable_from_prog_entry: " + is_reachable_str + "})"; + // SVFUtil::outs()<<"CallGraph Node Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs()<< "CallGraph node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add callGraph node to db " << dbname << " " + << result << "\n"; + } + return ret; + } + return false; +} + +bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, + const CallGraphEdge* edge, + const std::string& dbname) +{ + if (nullptr != connection) + { + std::string indirectCallIds = ""; + Set indirectCall = edge->getIndirectCalls(); + if (indirectCall.size() > 0) + { + indirectCallIds = extractNodesIds(indirectCall); + } + + std::string directCallIds = ""; + Set directCall = edge->getDirectCalls(); + if (directCall.size() > 0) + { + directCallIds = extractNodesIds(directCall); + } + + const std::string queryStatement = + "MATCH (n:CallGraphNode{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(edge->getDstNode()->getId()) + "}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(edge->getCallSiteID()) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + + indirectCallIds + "'}]->(m)"; + // SVFUtil::outs() << "Call Graph Edge Insert Query:" << queryStatement << "\n"; + std::string result; + bool ret = connection->CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "CallGraph edge added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add callgraph edge to db " << dbname << " " + << result << "\n"; + } + return ret; + } + return false; +} + +// pasre the directcallsIds/indirectcallsIds string to vector +std::vector GraphDBClient::stringToIds(const std::string& str) +{ + std::vector ids; + std::istringstream iss(str); + std::string token; + while (std::getline(iss, token, ',')) + { + ids.push_back(std::stoi(token)); + } + return ids; +} + +std::string GraphDBClient::getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node) { + const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getIntraICFGNodeInsertStmt(const IntraICFGNode* node) { + const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", is_return: " + (node->isRetInst() ? "true" : "false") + + ", bb_id:" + std::to_string(node->getBB()->getId()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getInterICFGNodeInsertStmt(const InterICFGNode* node) { + const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node) { + const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", fp_nodes:'" + extractNodesIds(node->getFormalParms()) +"'})"; + return queryStatement; +} + +std::string GraphDBClient::getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node) { + std::string formalRetId = ""; + if (node->getFormalRet() == nullptr) + { + formalRetId = ""; + } else { + formalRetId = ",formal_ret_node_id:" + std::to_string(node->getFormalRet()->getId()); + } + const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + formalRetId + "})"; + return queryStatement; +} + +std::string GraphDBClient::getCallICFGNodeInsertStmt(const CallICFGNode* node) { + std::string fun_name_of_v_call = ""; + std::string vtab_ptr_node_id = ""; + std::string virtual_fun_idx = "0"; + std::string is_vir_call_inst = node->isVirtualCall() ? "true" : "false"; + std::string virtualFunAppendix = ""; + if (node->isVirtualCall()) + { + fun_name_of_v_call = ", fun_name_of_v_call: '"+node->getFunNameOfVirtualCall()+"'"; + vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(node->getVtablePtr()->getId()); + virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(node->getFunIdxInVtable()); + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; + } + std::string called_fun_obj_var_id = ""; + if (node->getCalledFunction() != nullptr) + { + called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(node->getCalledFunction()->getId()); + } + const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()) + + ", bb_id: " + std::to_string(node->getBB()->getId()) + + ", svf_type:'" + node->getType()->toString() + + "', ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'"+ + called_fun_obj_var_id + + ", is_vararg: " + (node->isVarArg() ? "true" : "false") + + ", is_vir_call_inst: " + (node->isVirtualCall() ? "true" : "false") + + virtualFunAppendix+"})"; + return queryStatement; +} + +std::string GraphDBClient::getRetICFGNodeInsertStmt(const RetICFGNode* node) { + std::string actual_ret_node_id=""; + if (node->getActualRet() != nullptr) + { + actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(node->getActualRet()->getId()) ; + } + const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + actual_ret_node_id+ + ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getICFGNodeKindString(const ICFGNode* node) +{ + if(SVFUtil::isa(node)) + { + return "GlobalICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "FunEntryICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "FunExitICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "CallICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "RetICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "InterICFGNode"; + } + else if (SVFUtil::isa(node)) + { + return "IntraICFGNode"; + } + else + { + assert("unknown icfg node type?"); + return ""; + } +} + +std::string GraphDBClient::getIntraCFGEdgeStmt(const IntraCFGEdge* edge) { + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + std::string condition = ""; + if (edge->getCondition() != nullptr) + { + condition = ", condition_var_id:"+ std::to_string(edge->getCondition()->getId()) + + ", branch_cond_val:" + std::to_string(edge->getSuccessorCondValue()); + } + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + condition + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::getCallCFGEdgeStmt(const CallCFGEdge* edge) { + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + ", call_pe_ids:'"+ extractEdgesIds(edge->getCallPEs()) + + "'}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::getRetCFGEdgeStmt(const RetCFGEdge* edge) { + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + std::string ret_pe_id =""; + if (edge->getRetPE() != nullptr) + { + ret_pe_id = ", ret_pe_id:"+ std::to_string(edge->getRetPE()->getEdgeID()); + } + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + ret_pe_id+ + "}]->(m)"; + return queryStatement; +} + +void GraphDBClient::insertICFG2db(const ICFG* icfg) +{ + // add all ICFG Node & Edge to DB + if (nullptr != connection) + { + // create a new graph name ICFG in db + createSubGraph(connection, "ICFG"); + // load schema for CallGraph + std::string ICFGNodePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/ICFGNodeSchema.json"; + std::string ICFGEdgePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json"; + loadSchema(connection, ICFGNodePath.c_str(), "ICFG"); + loadSchema(connection, ICFGEdgePath.c_str(), "ICFG"); + std::vector edges; + for (auto it = icfg->begin(); it != icfg->end(); ++it) + { + ICFGNode* node = it->second; + addICFGNode2db(connection, node, "ICFG"); + for (auto edgeIter = node->OutEdgeBegin(); + edgeIter != node->OutEdgeEnd(); ++edgeIter) + { + ICFGEdge* edge = *edgeIter; + edges.push_back(edge); + } + } + for (auto edge : edges) + { + addICFGEdge2db(connection, edge, "ICFG"); + } + } +} + +void GraphDBClient::insertCallGraph2db(const CallGraph* callGraph) +{ + + std::string callGraphNodePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json"; + std::string callGraphEdgePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json"; + // add all CallGraph Node & Edge to DB + if (nullptr != connection) + { + // create a new graph name CallGraph in db + createSubGraph(connection, "CallGraph"); + // load schema for CallGraph + SVF::GraphDBClient::getInstance().loadSchema( + connection, + callGraphEdgePath, + "CallGraph"); + SVF::GraphDBClient::getInstance().loadSchema( + connection, + callGraphNodePath, + "CallGraph"); + std::vector edges; + for (const auto& item : *callGraph) + { + const CallGraphNode* node = item.second; + SVF::GraphDBClient::getInstance().addCallGraphNode2db( + connection, node, "CallGraph"); + for (CallGraphEdge::CallGraphEdgeSet::iterator iter = + node->OutEdgeBegin(); + iter != node->OutEdgeEnd(); ++iter) + { + const CallGraphEdge* edge = *iter; + edges.push_back(edge); + } + } + for (const auto& edge : edges) + { + SVF::GraphDBClient::getInstance().addCallGraphEdge2db(connection, edge, "CallGraph"); + } + + } else { + SVFUtil::outs() << "No DB connection, skip inserting CallGraph to DB\n"; + } +} + +void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, const Set* stInfos, std::string& dbname) +{ + if (nullptr != connection) + { + // create a new graph name SVFType in db + createSubGraph(connection, "SVFType"); + // load schema for SVFType + loadSchema(connection, SVF_ROOT "/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json", "SVFType"); + + // load & insert each svftype node to db + for (const auto& ty : *types) + { + std::string queryStatement; + if (SVFUtil::isa(ty)) + { + queryStatement = getSVFPointerTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else if (SVFUtil::isa(ty)) + { + queryStatement = getSVFIntegerTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else if (SVFUtil::isa(ty)) + { + queryStatement = getSVFFunctionTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else if (SVFUtil::isa(ty)) + { + queryStatement = getSVFSturctTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else if (SVFUtil::isa(ty)) + { + queryStatement = getSVFArrayTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else if (SVFUtil::isa(ty)) + { + queryStatement = getSVFOtherTypeNodeInsertStmt(SVFUtil::cast(ty)); + } + else + { + assert("unknown SVF type?"); + return ; + } + + // SVFUtil::outs()<<"SVFType Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs()<< "SVFType node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add SVFType node to db " << dbname << " " + << result << "\n"; + } + + } + + // load & insert each stinfo node to db + for(const auto& stInfo : *stInfos) + { + // insert stinfo node to db + std::string queryStatement = getStInfoNodeInsertStmt(stInfo); + // SVFUtil::outs()<<"StInfo Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs()<< "StInfo node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add StInfo node to db " << dbname << " " + << result << "\n"; + } + } + } + +} + +std::string GraphDBClient::getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFPointerTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFIntegerTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + + ", single_and_width:" + std::to_string(node->getSignAndWidth()) + "})"; + return queryStatement; +} + +std::string GraphDBClient::getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFFunctionTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + + ", params_types_vec:'" + extractSVFTypes(node->getParamTypes()) + + "', ret_ty_node_name:'" + node->getReturnType()->toString() + "'})"; + return queryStatement; +} + +std::string GraphDBClient::getSVFSturctTypeNodeInsertStmt(const SVFStructType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFStructTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", stinfo_node_id:" + std::to_string(node->getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + + ", struct_name:'" + node->getName() + "'})"; + return queryStatement; +} + +std::string GraphDBClient::getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFArrayTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", stinfo_node_id:" + std::to_string(node->getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + + ", num_of_element:" + std::to_string(node->getNumOfElement()) + + ", type_of_element_node_type_name:'" + node->getTypeOfElement()->toString() + "'})"; + return queryStatement; +} + +std::string GraphDBClient::getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node) +{ + std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFOtherTypeNode {type_name:'" + node->toString() + + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + + "', kind:" + std::to_string(node->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(node->getByteSize()) + + ", repr:'" + node->getRepr() + "'})"; + return queryStatement; +} + +std::string GraphDBClient::getStInfoNodeInsertStmt(const StInfo* node) +{ + const std::string queryStatement ="CREATE (n:StInfoNode {id:" + std::to_string(node->getStinfoId()) + + ", fld_idx_vec:'" + extractIdxs(node->getFlattenedFieldIdxVec()) + + "', elem_idx_vec:'" + extractIdxs(node->getFlattenedElemIdxVec()) + + "', finfo_types:'" + extractSVFTypes(node->getFlattenFieldTypes()) + + "', flatten_element_types:'" + extractSVFTypes(node->getFlattenElementTypes()) + + "', fld_idx_2_type_map:'" + extractFldIdx2TypeMap(node->getFldIdx2TypeMap()) + + "', stride:" + std::to_string(node->getStride()) + + ", num_of_flatten_elements:" + std::to_string(node->getNumOfFlattenElements()) + + ", num_of_flatten_fields:" + std::to_string(node->getNumOfFlattenFields()) + "})"; + return queryStatement; +} + +void GraphDBClient::insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph) +{ + if (nullptr != connection) + { + std::vector edges; + for (auto& bb: *bbGraph) + { + SVFBasicBlock* node = bb.second; + insertBBNode2db(connection, node, "BasicBlockGraph"); + for (auto iter = node->OutEdgeBegin(); iter != node->OutEdgeEnd(); ++iter) + { + edges.push_back(*iter); + } + } + for (const BasicBlockEdge* edge : edges) + { + insertBBEdge2db(connection, edge, "BasicBlockGraph"); + } + } +} + +void GraphDBClient::insertBBEdge2db(lgraph::RpcClient* connection, const BasicBlockEdge* edge, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement = getBBEdgeInsertStmt(edge); + // SVFUtil::outs()<<"BBEdge Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "BB edge added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add BB edge to db " << dbname + << " " << result << "\n"; + } + } + } +} + +void GraphDBClient::insertBBNode2db(lgraph::RpcClient* connection, const SVFBasicBlock* node, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement = getBBNodeInsertStmt(node); + // SVFUtil::outs()<<"BBNode Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "BB node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add BB node to db " << dbname + << " " << result << "\n"; + } + } + } +} + +std::string GraphDBClient::getBBNodeInsertStmt(const SVFBasicBlock* node) +{ + const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(node->getId())+":" + std::to_string(node->getFunction()->getId()) + "'" + + ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + + ", sscc_bb_ids:'" + extractNodesIds(node->getSuccBBs()) + "'" + + ", pred_bb_ids:'" + extractNodesIds(node->getPredBBs()) + "'" + + ", all_icfg_nodes_ids:'" + extractNodesIds(node->getICFGNodeList()) + "'" + + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getBBEdgeInsertStmt(const BasicBlockEdge* edge) +{ + const std::string queryStatement = + "MATCH (n:SVFBasicBlock {id:'"+std::to_string(edge->getSrcID())+":"+std::to_string(edge->getSrcNode()->getFunction()->getId())+"'}), (m:SVFBasicBlock{id:'"+std::to_string(edge->getDstID())+":"+std::to_string(edge->getDstNode()->getFunction()->getId())+ + "'}) WHERE n.id = '" +std::to_string(edge->getSrcID())+":" + std::to_string(edge->getSrcNode()->getFunction()->getId())+ "'"+ + " AND m.id = '" +std::to_string(edge->getDstID())+":" + std::to_string(edge->getDstNode()->getFunction()->getId())+ "'"+ + " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; + return queryStatement; +} + +void GraphDBClient::insertPAG2db(const PAG* pag) +{ + std::string pagNodePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; + std::string pagEdgePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/PAGEdgeSchema.json"; + std::string bbNodePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json"; + std::string bbEdgePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json"; + + // add all PAG Node & Edge to DB + if (nullptr != connection) + { + // create a new graph name PAG in db + createSubGraph(connection, "PAG"); + // create a new graph name BasicBlockGraph in db + createSubGraph(connection, "BasicBlockGraph"); + // load schema for PAG + SVF::GraphDBClient::getInstance().loadSchema(connection, pagEdgePath, + "PAG"); + SVF::GraphDBClient::getInstance().loadSchema(connection, pagNodePath, + "PAG"); + // load schema for PAG + SVF::GraphDBClient::getInstance().loadSchema(connection, bbEdgePath, + "BasicBlockGraph"); + SVF::GraphDBClient::getInstance().loadSchema(connection, bbNodePath, + "BasicBlockGraph"); + + std::vector edges; + for (auto it = pag->begin(); it != pag->end(); ++it) + { + SVFVar* node = it->second; + insertPAGNode2db(connection, node, "PAG"); + for (auto edgeIter = node->OutEdgeBegin(); + edgeIter != node->OutEdgeEnd(); ++edgeIter) + { + SVFStmt* edge = *edgeIter; + edges.push_back(edge); + } + } + for (auto edge : edges) + { + insertPAGEdge2db(connection, edge, "PAG"); + } + } + else + { + SVFUtil::outs() << "No DB connection, skip inserting CallGraph to DB\n"; + } +} + +void GraphDBClient::insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* edge, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement = getPAGEdgeInsertStmt(edge); + // SVFUtil::outs()<<"PAGEdge Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "PAG edge added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add PAG edge to db " << dbname + << " " << result << "\n"; + } + } + } +} + +std::string GraphDBClient::getPAGEdgeInsertStmt(const SVFStmt* edge) +{ + std::string queryStatement = ""; + if(SVFUtil::isa(edge)) + { + queryStatement = generateTDForkPEEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateTDJoinPEEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateCallPEEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateRetPEEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateGepStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateLoadStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateStoreStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateCopyStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateAddrStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateAssignStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generatePhiStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateSelectStmtEndgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateCmpStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateBinaryOPStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateMultiOpndStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = genereateUnaryOPStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateBranchStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else if(SVFUtil::isa(edge)) + { + queryStatement = generateSVFStmtEdgeInsertStmt(SVFUtil::cast(edge)); + } + else + { + assert("unknown SVFStmt type?"); + } + return queryStatement; +} + +void GraphDBClient::insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement = getPAGNodeInsertStmt(node); + // SVFUtil::outs()<<"PAGNode Insert Query:"<CallCypher(result, queryStatement, dbname); + if (ret) + { + SVFUtil::outs() << "PAG node added: " << result << "\n"; + } + else + { + SVFUtil::outs() << "Failed to add PAG node to db " << dbname + << " " << result << "\n"; + } + } + } +} + +std::string GraphDBClient::getPAGNodeInsertStmt(const SVFVar* node) +{ + std::string queryStatement = ""; + if(SVFUtil::isa(node)) + { + queryStatement = getConstNullPtrValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstIntValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstFPValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getBlackHoleValvarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstDataValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getRetValPNNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getVarArgValPNNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getDummyValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstAggValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getGlobalValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getFunValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getGepValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getArgValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getValVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstNullPtrObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstIntObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstFPObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstDataObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getDummyObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getConstAggObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getGlobalObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + const FunObjVar* funObjVar = SVFUtil::cast(node); + queryStatement = getFunObjVarNodeInsertStmt(funObjVar); + if ( nullptr != funObjVar->getBasicBlockGraph()) + { + insertBasicBlockGraph2db(funObjVar->getBasicBlockGraph()); + } + } + else if(SVFUtil::isa(node)) + { + queryStatement = getStackObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getHeapObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getBaseObjNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getGepObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else if(SVFUtil::isa(node)) + { + queryStatement = getObjVarNodeInsertStmt(SVFUtil::cast(node)); + } + else + { + assert("unknown SVFVar type?"); + } + return queryStatement; +} + +std::string GraphDBClient::getSVFVarNodeFieldsStmt(const SVFVar* node) +{ + std::string fieldsStr = ""; + fieldsStr += "id: " + std::to_string(node->getId()) + + ", svf_type_name:'"+node->getType()->toString() + + "', in_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(node->getInEdgeKindToSetMap()) + + "', out_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(node->getOutEdgeKindToSetMap()) + + "'"; + return fieldsStr; +} + +std::string GraphDBClient::getValVarNodeFieldsStmt(const ValVar* node) +{ + std::string fieldsStr = getSVFVarNodeFieldsStmt(node); + if ( nullptr != node->getICFGNode()) + { + fieldsStr += ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); + } + return fieldsStr; +} + +std::string GraphDBClient::getValVarNodeInsertStmt(const ValVar* node) +{ + const std::string queryStatement ="CREATE (n:ValVar {"+ + getValVarNodeFieldsStmt(node)+ + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node) +{ + return getValVarNodeFieldsStmt(node); +} + + +std::string GraphDBClient::getConstDataValVarNodeInsertStmt(const ConstDataValVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ + getConstDataValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node) +{ + const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ + getConstDataValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstFPValVarNodeInsertStmt(const ConstFPValVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ + getConstDataValVarNodeFieldsStmt(node) + +", kind:" + std::to_string(node->getNodeKind()) + +", dval:"+ std::to_string(node->getFPValue()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstIntValVarNodeInsertStmt(const ConstIntValVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ + getConstDataValVarNodeFieldsStmt(node) + +", kind:" + std::to_string(node->getNodeKind()) + +", zval:'"+ std::to_string(node->getZExtValue()) + "'" + +", sval:"+ std::to_string(node->getSExtValue()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstNullPtrValVarNodeInsertStmt(const ConstNullPtrValVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ + getConstDataValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getRetValPNNodeInsertStmt(const RetValPN* node) +{ + const std::string queryStatement ="CREATE (n:RetValPN {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + +", call_graph_node_id:"+std::to_string(node->getCallGraphNode()->getId()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getVarArgValPNNodeInsertStmt(const VarArgValPN* node) +{ + const std::string queryStatement ="CREATE (n:VarArgValPN {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + +", call_graph_node_id:"+std::to_string(node->getFunction()->getId()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getDummyValVarNodeInsertStmt(const DummyValVar* node) +{ + const std::string queryStatement ="CREATE (n:DummyValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstAggValVarNodeInsertStmt(const ConstAggValVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getGlobalValVarNodeInsertStmt(const GlobalValVar* node) +{ + const std::string queryStatement ="CREATE (n:GlobalValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getFunValVarNodeInsertStmt(const FunValVar* node) +{ + const std::string queryStatement ="CREATE (n:FunValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", fun_obj_var_node_id:" + std::to_string(node->getFunction()->getId()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getGepValVarNodeInsertStmt(const GepValVar* node) +{std::ostringstream accessPathFieldsStr; + accessPathFieldsStr << ""; + + if (nullptr != node->getAccessPath().gepSrcPointeeType()) + { + accessPathFieldsStr << ", ap_gep_pointee_type_name:'"<getAccessPath().gepSrcPointeeType()->toString()<<"'"; + } + if (!node->getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< IdxOperandPairsToString(&node->getAccessPath().getIdxOperandPairVec())<<"'"; + } + const std::string queryStatement ="CREATE (n:GepValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", base_val_id:" + std::to_string(node->getBaseNode()->getId()) + + ", gep_val_svf_type_name:'"+node->getType()->toString()+"'" + + ", ap_fld_idx:"+std::to_string(node->getConstantFieldIdx()) + + accessPathFieldsStr.str() + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getArgValVarNodeInsertStmt(const ArgValVar* node) +{ + const std::string queryStatement ="CREATE (n:ArgValVar {"+ + getValVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", cg_node_id:" + std::to_string(node->getParent()->getId()) + + ", arg_no:" + std::to_string(node->getArgNo()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getObjVarNodeFieldsStmt(const ObjVar* node) +{ + return getSVFVarNodeFieldsStmt(node); +} + +std::string GraphDBClient::getObjVarNodeInsertStmt(const ObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ObjVar {"+ + getObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getBaseObjVarNodeFieldsStmt(const BaseObjVar* node) +{ + std::string fieldsStr; + std::string icfgIDstr = ""; + if ( nullptr != node->getICFGNode()) + { + icfgIDstr = ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); + } + std::string objTypeInfo_byteSize_str = ""; + if (node->isConstantByteSize()) + { + objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + std::to_string(node->getByteSizeOfObj()); + } + fieldsStr += getObjVarNodeFieldsStmt(node) + + icfgIDstr + + ", obj_type_info_type_name:'" + node->getTypeInfo()->getType()->toString() + "'" + + ", obj_type_info_flags:" + std::to_string(node->getTypeInfo()->getFlag()) + + ", obj_type_info_max_offset_limit:" + std::to_string(node->getMaxFieldOffsetLimit()) + + ", obj_type_info_elem_num:" + std::to_string(node->getNumOfElements()) + + objTypeInfo_byteSize_str; + return fieldsStr; +} + +std::string GraphDBClient::getBaseObjNodeInsertStmt(const BaseObjVar* node) +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getGepObjVarNodeInsertStmt(const GepObjVar* node) +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", base_obj_var_node_id:" + std::to_string(node->getBaseObj()->getId()) + + ", app_offset:" + std::to_string(node->getConstantFieldIdx()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getHeapObjVarNodeInsertStmt(const HeapObjVar* node) +{ + const std::string queryStatement ="CREATE (n:HeapObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getStackObjVarNodeInsertStmt(const StackObjVar* node) +{ + const std::string queryStatement ="CREATE (n:StackObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node) +{ + return getBaseObjVarNodeFieldsStmt(node); +} + +std::string GraphDBClient::getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ + getConstDataObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstNullPtrObjVarNodeInsertStmt(const ConstNullPtrObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ + getConstDataObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ + getConstDataObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", zval:'" + std::to_string(node->getZExtValue()) + "'" + + ", sval:" + std::to_string(node->getSExtValue()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ + getConstDataObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", dval:" + std::to_string(node->getFPValue()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getDummyObjVarNodeInsertStmt(const DummyObjVar* node) +{ + const std::string queryStatement ="CREATE (n:DummyObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node) +{ + const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node) +{ + const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getFunObjVarNodeInsertStmt(const FunObjVar* node) +{ + /// TODO: add bbGraph to bbGraph_tuGraph DB + std::ostringstream exitBBStr; + if (node->hasBasicBlock() && nullptr != node->getExitBB()) + { + exitBBStr << ", exit_bb_id:" << std::to_string(node->getExitBB()->getId()); + } + const std::string queryStatement ="CREATE (n:FunObjVar {"+ + getBaseObjVarNodeFieldsStmt(node) + + ", kind:" + std::to_string(node->getNodeKind()) + + ", is_decl:" + (node->isDeclaration()? "true" : "false") + + ", intrinsic:" + (node->isIntrinsic()? "true" : "false") + + ", is_addr_taken:" + (node->hasAddressTaken()? "true" : "false") + + ", is_uncalled:" + (node->isUncalledFunction()? "true" : "false") + + ", is_not_ret:" + (node->hasReturn()? "true" : "false") + + ", sup_var_arg:" + (node->isVarArg()? "true" : "false") + + ", fun_type_name:'" + node->getFunctionType()->toString() + "'" + + ", real_def_fun_node_id:" + std::to_string(node->getDefFunForMultipleModule()->getId()) + // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) + + exitBBStr.str() + + ", all_args_node_ids:'" + extractNodesIds(node->getArgs()) + "'" + + ", reachable_bbs:'" + extractNodesIds(node->getReachableBBs()) + "'" + + ", dt_bbs_map:'" + extractBBsMapWithSet2String(&(node->getDomTreeMap())) + "'" + + ", pdt_bbs_map:'" + extractBBsMapWithSet2String(&(node->getLoopAndDomInfo()->getPostDomTreeMap())) + "'" + + ", df_bbs_map:'" + extractBBsMapWithSet2String(&(node->getDomFrontierMap())) + "'" + + ", bb2_loop_map:'" + extractBBsMapWithSet2String(&(node->getLoopAndDomInfo()->getBB2LoopMap())) + "'" + + ", bb2_p_dom_level:'" + extractLabelMap2String(&(node->getLoopAndDomInfo()->getBBPDomLevel())) + "'" + + ", bb2_pi_dom:'" + extractBBsMap2String(&(node->getLoopAndDomInfo()->getBB2PIdom())) + "'" + + "})"; + return queryStatement; +} + +std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge) +{ + std::string valueStr = ""; + if (nullptr != edge->getValue()) + { + valueStr += ", svf_var_node_id:"+ std::to_string(edge->getValue()->getId()); + } + std::string bb_id_str = ""; + if (nullptr != edge->getBB()) + { + bb_id_str += ", bb_id:" + std::to_string(edge->getBB()->getId()); + } + + std::string icfg_node_id_str = ""; + if (nullptr != edge->getICFGNode()) + { + icfg_node_id_str += ", icfg_node_id:" + std::to_string(edge->getICFGNode()->getId()); + } + + std::string inst2_label_map = ""; + if (nullptr != edge->getInst2LabelMap() && !edge->getInst2LabelMap()->empty()) + { + inst2_label_map += ", inst2_label_map:'"+ extractLabelMap2String(edge->getInst2LabelMap()) +"'"; + } + + std::string var2_label_map = ""; + if (nullptr != edge->getVar2LabelMap() && !edge->getVar2LabelMap()->empty()) + { + var2_label_map += ", var2_label_map:'"+ extractLabelMap2String(edge->getVar2LabelMap()) +"'"; + } + std::string fieldsStr = ""; + fieldsStr += "edge_id: " + std::to_string(edge->getEdgeID()) + + valueStr + + bb_id_str + + icfg_node_id_str + + inst2_label_map + + var2_label_map + + ", call_edge_label_counter:" + std::to_string(*(edge->getCallEdgeLabelCounter())) + + ", store_edge_label_counter:" + std::to_string(*(edge->getStoreEdgeLabelCounter())) + + ", multi_opnd_label_counter:" + std::to_string(*(edge->getMultiOpndLabelCounter())); + return fieldsStr; +} + +std::string GraphDBClient::generateSVFStmtEdgeInsertStmt(const SVFStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getSrcNode()); + std::string dstKind = getPAGNodeKindString(edge->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:SVFStmt{"+ + generateSVFStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateAssignStmtFieldsStmt(const AssignStmt* edge) +{ + return generateSVFStmtEdgeFieldsStmt(edge); +} + +std::string GraphDBClient::generateAssignStmtEdgeInsertStmt(const AssignStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:AssignStmt{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateAddrStmtEdgeInsertStmt(const AddrStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:AddrStmt{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", arr_size:'" + extractNodesIds(edge->getArrSize()) +"'"+ + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateCopyStmtEdgeInsertStmt(const CopyStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:CopyStmt{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", copy_kind:" + std::to_string(edge->getCopyKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateStoreStmtEdgeInsertStmt(const StoreStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:StoreStmt{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateLoadStmtEdgeInsertStmt(const LoadStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:LoadStmt{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateGepStmtEdgeInsertStmt(const GepStmt* edge) +{ + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + std::ostringstream accessPathStr; + accessPathStr << ""; + if (!edge->isVariantFieldGep()) + { + accessPathStr << ", ap_fld_idx:" + << std::to_string(edge->getConstantStructFldIdx()); + } + + if (nullptr != edge->getAccessPath().gepSrcPointeeType()) + { + accessPathStr << ", ap_gep_pointee_type_name:'" + << edge->getAccessPath().gepSrcPointeeType()->toString() + << "'"; + } + if (!edge->getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathStr << ", ap_idx_operand_pairs:'" + << IdxOperandPairsToString( + &edge->getAccessPath().getIdxOperandPairVec()) + << "'"; + } + + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + accessPathStr.str() + + ", variant_field:" + (edge->isVariantFieldGep()? "true" : "false") + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateCallPEEdgeInsertStmt(const CallPE* edge) +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != edge->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); + } + + if (nullptr != edge->getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); + } + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:CallPE{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateRetPEEdgeInsertStmt(const RetPE* edge) +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != edge->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); + } + + if (nullptr != edge->getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); + } + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:RetPE{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateTDForkPEEdgeInsertStmt(const TDForkPE* edge) +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != edge->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); + } + + if (nullptr != edge->getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); + } + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:TDForkPE{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge) +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != edge->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); + } + + if (nullptr != edge->getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); + } + std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); + std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(edge->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + + " CREATE (n)-[r:TDJoinPE{"+ + generateAssignStmtFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge) +{ + std::string stmt = generateSVFStmtEdgeFieldsStmt(edge); + if (! edge->getOpndVars().empty()) + { + stmt += ", op_var_node_ids:'" + extractNodesIds(edge->getOpndVars())+"'"; + } + return stmt; +} + +std::string GraphDBClient::generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:MultiOpndStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generatePhiStmtEdgeInsertStmt(const PhiStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:PhiStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", op_icfg_nodes_ids:'" + extractNodesIds(*(edge->getOpICFGNodeVec())) + "'"+ + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateSelectStmtEndgeInsertStmt(const SelectStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:SelectStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", condition_svf_var_node_id:" + std::to_string(edge->getCondition()->getId()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateCmpStmtEdgeInsertStmt(const CmpStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:CmpStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", predicate:" + std::to_string(edge->getPredicate()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:BinaryOPStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", op_code:" + std::to_string(edge->getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:UnaryOPStmt{"+ + generateSVFStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", op_code:" + std::to_string(edge->getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::generateBranchStmtEdgeInsertStmt(const BranchStmt* edge) +{ + const SVFStmt* stmt = SVFUtil::cast(edge); + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:BranchStmt{"+ + generateSVFStmtEdgeFieldsStmt(edge) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", successors:'" + extractSuccessorsPairSet2String(&(edge->getSuccessors())) + "'"+ + ", condition_svf_var_node_id:" + std::to_string(edge->getCondition()->getId()) + + ", br_inst_svf_var_node_id:" + std::to_string(edge->getBranchInst()->getId()) + + "}]->(m)"; + return queryStatement; +} + +std::string GraphDBClient::getPAGNodeKindString(const SVFVar* node) +{ + if(SVFUtil::isa(node)) + { + return "ConstNullPtrValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstIntValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstFPValVar"; + } + else if(SVFUtil::isa(node)) + { + return "BlackHoleValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstDataValVar"; + } + else if(SVFUtil::isa(node)) + { + return "RetValPN"; + } + else if(SVFUtil::isa(node)) + { + return "VarArgValPN"; + } + else if(SVFUtil::isa(node)) + { + return "DummyValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstAggValVar"; + } + else if(SVFUtil::isa(node)) + { + return "GlobalValVar"; + } + else if(SVFUtil::isa(node)) + { + return "FunValVar"; + } + else if(SVFUtil::isa(node)) + { + return "GepValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ArgValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ValVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstNullPtrObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstIntObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstFPObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstDataObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "DummyObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "ConstAggObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "GlobalObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "FunObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "StackObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "HeapObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "BaseObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "GepObjVar"; + } + else if(SVFUtil::isa(node)) + { + return "ObjVar"; + } + + assert("unknown SVFVar node type?"); + return "SVFVar"; + +} diff --git a/svf/lib/SVFIR/SVFType.cpp b/svf/lib/SVFIR/SVFType.cpp index a464cda7e..7729c7143 100644 --- a/svf/lib/SVFIR/SVFType.cpp +++ b/svf/lib/SVFIR/SVFType.cpp @@ -1,5 +1,6 @@ #include "SVFIR/SVFType.h" #include +#include "SVFIR/GraphDBClient.h" namespace SVF { @@ -89,4 +90,48 @@ void SVFOtherType::print(std::ostream& os) const os << repr; } -} // namespace SVF +std::string SVFFunctionType::toDBString() const +{ + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFFunctionType {id:" + std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + + ", params_types_vec:'" + GraphDBClient::getInstance().extractSVFTypes(getParamTypes()) + + "', ret_ty_node_id:" + std::to_string(getReturnType()->getId()) + "})"; + return queryStatement; +} + +std::string StInfo::toDBString() const +{ + const std::string queryStatement ="CREATE (n:StInfo {st_info_id:" + std::to_string(getStinfoId()) + + ", fld_idx_vec:'" + GraphDBClient::getInstance().extractIdxs(getFlattenedFieldIdxVec()) + + "', elem_idx_vec:'" + GraphDBClient::getInstance().extractIdxs(getFlattenedElemIdxVec()) + + "', finfo_types:'" + GraphDBClient::getInstance().extractSVFTypes(getFlattenFieldTypes()) + + "', flatten_element_types:'" + GraphDBClient::getInstance().extractSVFTypes(getFlattenElementTypes()) + + "', fld_idx_2_type_map:'" + GraphDBClient::getInstance().extractFldIdx2TypeMap(getFldIdx2TypeMap()) + + "', stride:" + std::to_string(getStride()) + + ", num_of_flatten_elements:" + std::to_string(getNumOfFlattenElements()) + + ", num_of_flatten_fields:" + std::to_string(getNumOfFlattenFields()) + "})"; + return queryStatement; +} + +std::string SVFStructType::toDBString() const +{ + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFStructType {id:" + std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", stinfo_node_id:" + std::to_string(getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + + ", struct_name:'" + getName() + "'" + + ", fields_id_vec:'" + GraphDBClient::getInstance().extractSVFTypes(getFieldTypes()) + + "'})"; + return queryStatement; +} + +} // namespace SVF \ No newline at end of file diff --git a/svf/lib/Util/Options.cpp b/svf/lib/Util/Options.cpp index a783ce4e9..05a2c1ecc 100644 --- a/svf/lib/Util/Options.cpp +++ b/svf/lib/Util/Options.cpp @@ -629,6 +629,18 @@ const Option Options::PrintCGGraph( false ); +const Option Options::Write2DB( + "write2db", + "Write Graphs' nodes & edges to a graphDB", + false +); + +const Option Options::ReadFromDB( + "read-from-db", + "Read Graphs' nodes & edges from a graphDB", + false +); + const Option Options::WriteAnder( "write-ander", "Write Andersen's analysis results to a user-specified text file", From eb13c54fb1e18f2d0eee296a66da482553cda712 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 31 Mar 2025 02:31:20 +1100 Subject: [PATCH 02/19] - read SVFType From DB [tested] - read SVFType from db - init PAGNode from db - read SVFBBGraph from db - read ICFG from db read ICFG edge from db [tested & checked] - read & write pag edge [tested] - fixed stat err --- svf-llvm/tools/WPA/wpa.cpp | 6 + svf/include/Graphs/BasicBlockG.h | 7 + svf/include/Graphs/CHG.h | 11 + svf/include/Graphs/CallGraph.h | 21 + .../Graphs/DBSchema/BasicBlockNodeSchema.json | 6 + .../Graphs/DBSchema/CHGEdgeSchema.json | 17 + .../Graphs/DBSchema/CHGNodeSchema.json | 35 + .../Graphs/DBSchema/CallGraphNodeSchema.json | 6 - .../Graphs/DBSchema/ICFGEdgeSchema.json | 8 +- .../Graphs/DBSchema/ICFGNodeSchema.json | 52 +- .../Graphs/DBSchema/PAGEdgeSchema.json | 264 +- .../Graphs/DBSchema/PAGNodeSchema.json | 55 +- .../Graphs/DBSchema/SVFTypeNodeSchema.json | 14 +- svf/include/Graphs/ICFG.h | 39 + svf/include/Graphs/ICFGEdge.h | 1 + svf/include/Graphs/ICFGNode.h | 60 + svf/include/Graphs/IRGraph.h | 21 + svf/include/MemoryModel/AccessPath.h | 5 + svf/include/SVFIR/GraphDBClient.h | 723 +++- svf/include/SVFIR/ObjTypeInfo.h | 8 + svf/include/SVFIR/SVFIR.h | 79 + svf/include/SVFIR/SVFStatements.h | 138 + svf/include/SVFIR/SVFType.h | 119 +- svf/include/SVFIR/SVFVariables.h | 274 +- svf/include/Util/NodeIDAllocator.h | 11 + svf/include/Util/SVFLoopAndDomInfo.h | 34 + svf/lib/Graphs/CallGraph.cpp | 73 +- svf/lib/Graphs/IRGraph.cpp | 11 + svf/lib/SVFIR/GraphDBClient.cpp | 3080 ++++++++++++++++- svf/lib/SVFIR/SVFIR.cpp | 132 + svf/lib/SVFIR/SVFStatements.cpp | 39 + 31 files changed, 4965 insertions(+), 384 deletions(-) create mode 100644 svf/include/Graphs/DBSchema/CHGEdgeSchema.json create mode 100644 svf/include/Graphs/DBSchema/CHGNodeSchema.json diff --git a/svf-llvm/tools/WPA/wpa.cpp b/svf-llvm/tools/WPA/wpa.cpp index ebb6b80e9..3980a2476 100644 --- a/svf-llvm/tools/WPA/wpa.cpp +++ b/svf-llvm/tools/WPA/wpa.cpp @@ -50,6 +50,12 @@ int main(int argc, char** argv) { assert(false && "please implement SVFIRReader::read"); } + else if (Options::ReadFromDB()) + { + SVFIRBuilder builder; + pag = builder.build(); + pag->setPagFromTXT("ReadFromDB"); + } else { LLVMModuleSet::buildSVFModule(moduleNameVec); diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index 2eaa40394..dffc66f06 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -74,6 +74,7 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy friend class FunObjVar; friend class ICFGBuilder; friend class ICFG; + friend class GraphDBClient; public: typedef std::vector::const_iterator const_iterator; @@ -318,6 +319,12 @@ class BasicBlockGraph: public GenericBasicBlockGraphTy return bb; } + void addBasicBlock(SVFBasicBlock* bb) + { + id++; + addGNode(bb->getId(), bb); + } + }; } diff --git a/svf/include/Graphs/CHG.h b/svf/include/Graphs/CHG.h index d0ca8fa46..eeb9860b5 100644 --- a/svf/include/Graphs/CHG.h +++ b/svf/include/Graphs/CHG.h @@ -105,6 +105,7 @@ class CHEdge: public GenericCHEdgeTy typedef GenericNode GenericCHNodeTy; class CHNode: public GenericCHNodeTy { + friend class GraphDBClient; public: typedef enum @@ -222,6 +223,16 @@ class CHNode: public GenericCHNodeTy * virtualFunctionVectors = {{Af1, Af2, ...}, {Bg1, Bg2, ...}} */ std::vector virtualFunctionVectors; + +protected: + inline size_t getFlags() const + { + return flags; + } + inline void setFlags(size_t f) + { + flags = f; + } }; /// class hierarchy graph diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index 8270da169..f01284722 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -233,6 +233,8 @@ class CallGraphNode : public GenericPTACallGraphNodeTy typedef GenericGraph GenericPTACallGraphTy; class CallGraph : public GenericPTACallGraphTy { + friend class GraphDBClient; + public: typedef CallGraphEdge::CallGraphEdgeSet CallGraphEdgeSet; @@ -288,6 +290,19 @@ class CallGraph : public GenericPTACallGraphTy return it->second; } + inline void addCallSite(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid) + { + std::pair newCS(std::make_pair(cs, callee)); + CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS); + if(it == csToIdMap.end()) + { + CallSiteID id = csid; + totalCallSiteNum++; + csToIdMap.insert(std::make_pair(newCS, id)); + idToCSMap.insert(std::make_pair(id, newCS)); + } + } + /// Add call graph edge inline void addEdge(CallGraphEdge* edge) { @@ -351,9 +366,12 @@ class CallGraph : public GenericPTACallGraphTy /// Add direct call edges void addDirectCallGraphEdge(const CallICFGNode* call, const FunObjVar* callerFun, const FunObjVar* calleeFun); + void addDirectCallGraphEdge(CallGraphEdge* cgEdge); void addCallGraphNode(const FunObjVar* fun); + void addCallGraphNodeFromDB(CallGraphNode* cgNode); + /// Get call graph node //@{ @@ -406,6 +424,8 @@ class CallGraph : public GenericPTACallGraphTy /// Whether we have already created this call graph edge CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId) const; + + CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge); /// Get call graph edge via nodes CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId); @@ -450,6 +470,7 @@ class CallGraph : public GenericPTACallGraphTy /// Add indirect call edges //@{ void addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* callerFun, const FunObjVar* calleeFun); + void addIndirectCallGraphEdge(CallGraphEdge* cgEdge); //@} /// Get callsites invoking the callee diff --git a/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json b/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json index 4c8a32ad2..0036a3060 100644 --- a/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json +++ b/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json @@ -17,6 +17,12 @@ "optional":false, "index":false }, + { + "name" : "bb_name", + "type":"STRING", + "optional":false, + "index":false + }, { "name":"sscc_bb_ids", "type":"STRING", diff --git a/svf/include/Graphs/DBSchema/CHGEdgeSchema.json b/svf/include/Graphs/DBSchema/CHGEdgeSchema.json new file mode 100644 index 000000000..3f8381d47 --- /dev/null +++ b/svf/include/Graphs/DBSchema/CHGEdgeSchema.json @@ -0,0 +1,17 @@ +{ + "schema": [ + { + "label":"CHEdge", + "type":"EDGE", + "properties" : [ + { + "name" : "edge_type", + "type":"INT32", + "optional":false, + "index":false + } + ] + } + ] +} + \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CHGNodeSchema.json b/svf/include/Graphs/DBSchema/CHGNodeSchema.json new file mode 100644 index 000000000..4789d08fa --- /dev/null +++ b/svf/include/Graphs/DBSchema/CHGNodeSchema.json @@ -0,0 +1,35 @@ +{ + "schema": [ + { + "label" : "CHNode", + "type" : "VERTEX", + "primary" : "class_name", + "properties" : [ + { + "name" : "class_name", + "type":"STRING", + "optional":false, + "index":true + }, + { + "name" : "vtable_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name" : "flags", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name" : "virtual_function_vectors", + "type":"STRING", + "optional":false, + "index":false + } + ] + } + ] +} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json index d4e89a83a..f3a24f061 100644 --- a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json +++ b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json @@ -16,12 +16,6 @@ "type":"INT32", "optional":false, "index":false - }, - { - "name":"is_reachable_from_prog_entry", - "type":"BOOL", - "optional":false, - "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json b/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json index 146bd705e..0fca65c54 100644 --- a/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json +++ b/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json @@ -13,13 +13,13 @@ { "name" : "condition_var_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { - "name" : "branch_condition_val", + "name" : "branch_cond_val", "type":"INT64", - "optional":true, + "optional":false, "index":false } ] @@ -55,7 +55,7 @@ { "name":"ret_pe_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] diff --git a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json index 07ec0bff1..28d86567d 100644 --- a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json @@ -47,6 +47,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false } ] }, @@ -97,6 +103,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":false, + "index":false } ] }, @@ -120,7 +132,7 @@ { "name":"formal_ret_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -128,6 +140,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":false, + "index":false } ] }, @@ -160,6 +178,12 @@ "optional":false, "index":false }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false + }, { "name":"svf_type", "type":"STRING", @@ -175,7 +199,7 @@ { "name":"called_fun_obj_var_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -193,13 +217,13 @@ { "name":"vtab_ptr_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"virtual_fun_idx", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -230,7 +254,7 @@ { "name":"actual_ret_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -238,6 +262,24 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"svf_type", + "type":"STRING", + "index":false, + "optional":false + }, + { + "name":"bb_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"fun_obj_var_id", + "type":"INT32", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json index 4a0e5a142..439f2ee3b 100644 --- a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json +++ b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json @@ -16,22 +16,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -82,22 +88,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -148,22 +160,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -196,12 +214,6 @@ "optional":false, "index":false }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, { "name":"arr_size", "type":"STRING", @@ -226,22 +238,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -298,22 +316,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -364,22 +388,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -430,22 +460,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -487,7 +523,7 @@ { "name":"ap_fld_idx", "type":"INT64", - "optional":true, + "optional":false, "index":false }, { @@ -520,22 +556,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -571,13 +613,13 @@ { "name":"call_icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"fun_entry_icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -598,22 +640,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -676,22 +724,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -748,22 +802,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -826,22 +886,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -904,22 +970,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -982,22 +1054,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1060,22 +1138,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1132,22 +1216,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1216,22 +1306,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1294,22 +1390,28 @@ "optional":false, "index":false }, + { + "name" : "edge_flag", + "type":"INT64", + "optional":false, + "index":false + }, { "name" : "svf_var_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { "name":"bb_id", - "type":"INT32", - "optional":true, + "type":"STRING", + "optional":false, "index":false }, { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { diff --git a/svf/include/Graphs/DBSchema/PAGNodeSchema.json b/svf/include/Graphs/DBSchema/PAGNodeSchema.json index 414431e2d..3772e8849 100644 --- a/svf/include/Graphs/DBSchema/PAGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/PAGNodeSchema.json @@ -75,7 +75,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -155,7 +155,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -210,7 +210,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -283,7 +283,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -405,7 +405,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -478,7 +478,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -551,7 +551,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -635,7 +635,7 @@ { "name":"exit_bb_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -687,7 +687,8 @@ "index":false } ] - }, { + }, + { "label" : "FunValVar", "type" : "VERTEX", "primary" : "id", @@ -725,7 +726,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -774,7 +775,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -817,7 +818,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -860,7 +861,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -903,7 +904,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -946,7 +947,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -995,7 +996,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1050,7 +1051,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -1093,7 +1094,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1166,7 +1167,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1239,7 +1240,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1312,7 +1313,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1391,7 +1392,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1476,7 +1477,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1549,7 +1550,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1598,7 +1599,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { @@ -1647,7 +1648,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false } ] @@ -1690,7 +1691,7 @@ { "name":"icfg_node_id", "type":"INT32", - "optional":true, + "optional":false, "index":false }, { diff --git a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json index 62c392add..46aa62de9 100644 --- a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json +++ b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json @@ -1,7 +1,7 @@ { "schema": [ { - "label" : "SVFPointerTypeNode", + "label" : "SVFPointerType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -44,7 +44,7 @@ ] }, { - "label" : "SVFIntegerTypeNode", + "label" : "SVFIntegerType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -93,7 +93,7 @@ ] }, { - "label" : "SVFFunctionTypeNode", + "label" : "SVFFunctionType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -148,7 +148,7 @@ ] }, { - "label" : "SVFStructTypeNode", + "label" : "SVFStructType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -203,7 +203,7 @@ ] }, { - "label" : "SVFArrayTypeNode", + "label" : "SVFArrayType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -264,7 +264,7 @@ ] }, { - "label" : "SVFOtherTypeNode", + "label" : "SVFOtherType", "type" : "VERTEX", "primary" : "type_name", "properties" : [ @@ -313,7 +313,7 @@ ] }, { - "label" : "StInfoNode", + "label" : "StInfo", "type" : "VERTEX", "primary" : "id", "properties" : [ diff --git a/svf/include/Graphs/ICFG.h b/svf/include/Graphs/ICFG.h index 88234a551..57793946c 100644 --- a/svf/include/Graphs/ICFG.h +++ b/svf/include/Graphs/ICFG.h @@ -48,6 +48,7 @@ class ICFG : public GenericICFGTy { friend class ICFGBuilder; friend class ICFGSimplification; + friend class GraphDBClient; public: @@ -174,6 +175,12 @@ class ICFG : public GenericICFGTy return intraIcfgNode; } + virtual inline void addIntraICFGNode(IntraICFGNode* intraICFGNode) + { + totalICFGNode++; + addICFGNode(intraICFGNode); + } + virtual inline CallICFGNode* addCallICFGNode( const SVFBasicBlock* bb, const SVFType* ty, const FunObjVar* calledFunc, bool isVararg, bool isvcall, @@ -187,6 +194,12 @@ class ICFG : public GenericICFGTy return callICFGNode; } + virtual inline void addCallICFGNode(CallICFGNode* callICFGNode) + { + totalICFGNode++; + addICFGNode(callICFGNode); + } + virtual inline RetICFGNode* addRetICFGNode(CallICFGNode* call) { RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call); @@ -194,6 +207,11 @@ class ICFG : public GenericICFGTy addICFGNode(retICFGNode); return retICFGNode; } + virtual inline void addRetICFGNode(RetICFGNode* retICFGNode) + { + totalICFGNode++; + addICFGNode(retICFGNode); + } virtual inline FunEntryICFGNode* addFunEntryICFGNode(const FunObjVar* svfFunc) { @@ -202,6 +220,20 @@ class ICFG : public GenericICFGTy return FunToFunEntryNodeMap[svfFunc] = sNode; } + virtual inline void addFunEntryICFGNode(FunEntryICFGNode* funEntryICFGNode) + { + totalICFGNode++; + addICFGNode(funEntryICFGNode); + FunToFunEntryNodeMap[funEntryICFGNode->getFun()] = funEntryICFGNode; + } + + virtual inline void addGlobalICFGNode(GlobalICFGNode* globalICFGNode) + { + totalICFGNode++; + this->globalBlockNode = globalICFGNode; + addICFGNode(globalICFGNode); + } + virtual inline FunExitICFGNode* addFunExitICFGNode(const FunObjVar* svfFunc) { FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc); @@ -209,6 +241,13 @@ class ICFG : public GenericICFGTy return FunToFunExitNodeMap[svfFunc] = sNode; } + virtual inline void addFunExitICFGNode(FunExitICFGNode* funExitICFGNode) + { + totalICFGNode++; + addICFGNode(funExitICFGNode); + FunToFunExitNodeMap[funExitICFGNode->getFun()] = funExitICFGNode; + } + /// Add a ICFG node virtual inline void addICFGNode(ICFGNode* node) { diff --git a/svf/include/Graphs/ICFGEdge.h b/svf/include/Graphs/ICFGEdge.h index 1beeac6bf..233ec4110 100644 --- a/svf/include/Graphs/ICFGEdge.h +++ b/svf/include/Graphs/ICFGEdge.h @@ -112,6 +112,7 @@ class IntraCFGEdge : public ICFGEdge { friend class ICFG; friend class SVFIRBuilder; + friend class GraphDBClient; public: /// Constructor diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index 5a62e6952..dc2928b79 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -192,6 +192,16 @@ class GlobalICFGNode : public ICFGNode */ class IntraICFGNode : public ICFGNode { + friend class GraphDBClient; + +protected: + IntraICFGNode(NodeID id, const SVFBasicBlock* bb, const FunObjVar* funObjVar, bool isReturn): ICFGNode(id, IntraBlock),isRet(isReturn) + { + + this->fun = funObjVar; + this->bb = bb; + } + private: bool isRet; @@ -270,6 +280,15 @@ class InterICFGNode : public ICFGNode */ class FunEntryICFGNode : public InterICFGNode { + friend class GraphDBClient; + +protected: + FunEntryICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb) + : InterICFGNode(id, FunEntryBlock) + { + this->fun = f; + this->bb = bb; + } public: typedef std::vector FormalParmNodeVec; @@ -335,6 +354,15 @@ class FunEntryICFGNode : public InterICFGNode */ class FunExitICFGNode : public InterICFGNode { + friend class GraphDBClient; + +protected: + FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb) + : InterICFGNode(id, FunExitBlock), formalRet(nullptr) + { + this->fun = f; + this->bb = bb; + } private: const SVFVar *formalRet; @@ -398,6 +426,7 @@ class FunExitICFGNode : public InterICFGNode */ class CallICFGNode : public InterICFGNode { + friend class GraphDBClient; public: typedef std::vector ActualParmNodeVec; @@ -412,6 +441,22 @@ class CallICFGNode : public InterICFGNode s32_t virtualFunIdx; /// virtual function index of the virtual table(s) at a virtual call std::string funNameOfVcall; /// the function name of this virtual call + /// Constructor to create empty CallICFGNode (for SVFIRReader/deserialization) + CallICFGNode(NodeID id) : InterICFGNode(id, FunCallBlock), ret{} {} + + CallICFGNode(NodeID id, const SVFBasicBlock* bb, const SVFType* type, + const FunObjVar* fun, const FunObjVar* cf, const RetICFGNode* ret, + bool iv, bool ivc, s32_t vfi, SVFVar* vtabPtr, const std::string& fnv) + : InterICFGNode(id, FunCallBlock), ret(ret), calledFunc(cf), + isvararg(iv), isVirCallInst(ivc), vtabPtr(vtabPtr), + virtualFunIdx(vfi), funNameOfVcall(fnv) + { + this->fun = fun; + this->bb = bb; + this->type = type; + } + + public: CallICFGNode(NodeID id, const SVFBasicBlock* b, const SVFType* ty, const FunObjVar* cf, bool iv, bool ivc, s32_t vfi, @@ -569,6 +614,16 @@ class CallICFGNode : public InterICFGNode */ class RetICFGNode : public InterICFGNode { + friend class GraphDBClient; + +protected: + RetICFGNode(NodeID id, const SVFType* type, const SVFBasicBlock* bb, const FunObjVar* funObjVar) : + InterICFGNode(id, FunRetBlock), actualRet(nullptr), callBlockNode(nullptr) + { + this->fun = funObjVar; + this->bb = bb; + this->type = type; + } private: const SVFVar *actualRet; @@ -599,6 +654,11 @@ class RetICFGNode : public InterICFGNode actualRet = ar; } + inline void addCallBlockNode(const CallICFGNode* cb) + { + callBlockNode = cb; + } + ///Methods for support type inquiry through isa, cast, and dyn_cast: //@{ static inline bool classof(const RetICFGNode *) diff --git a/svf/include/Graphs/IRGraph.h b/svf/include/Graphs/IRGraph.h index 08c8f352d..b10f29933 100644 --- a/svf/include/Graphs/IRGraph.h +++ b/svf/include/Graphs/IRGraph.h @@ -129,6 +129,7 @@ class IRGraph : public GenericGraph /// blocks, thus flags are needed to distinguish them SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind, const ICFGNode* cs); + SVFStmt* hasEdge(SVFStmt* edge, SVFStmt::PEDGEK kind); /// Return MultiOpndStmt since it has more than one operands (we use operand /// 2 here to make the flag) SVFStmt* hasLabeledEdge(SVFVar* src, SVFVar* op1, SVFStmt::PEDGEK kind, @@ -270,6 +271,26 @@ class IRGraph : public GenericGraph return svfTypes; } + inline const SVFType* getSVFType(const std::string& name) const + { + for(const SVFType* type : svfTypes) + { + if(type->toString() == name) + return type; + } + return nullptr; + } + + inline void addSVFTypes(const Set* types) + { + svfTypes.insert(types->begin(), types->end()); + } + + inline void addStInfos(const Set* stInfos) + { + this->stInfos.insert(stInfos->begin(), stInfos->end()); + } + inline const Set& getStInfos() const { return stInfos; diff --git a/svf/include/MemoryModel/AccessPath.h b/svf/include/MemoryModel/AccessPath.h index 9eb41e69d..17fab6160 100644 --- a/svf/include/MemoryModel/AccessPath.h +++ b/svf/include/MemoryModel/AccessPath.h @@ -161,6 +161,11 @@ class AccessPath /// Dump location set std::string dump() const; + inline void addIdxOperandPair(std::pair pair) + { + idxOperandPairs.push_back(pair); + } + private: /// Check relations of two location sets diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 103df8f76..1321cc39e 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -3,10 +3,12 @@ #include "Graphs/CallGraph.h" #include "Graphs/ICFGEdge.h" #include "Graphs/ICFGNode.h" -#include "SVFIR/SVFType.h" +#include "Graphs/CHG.h" #include "SVFIR/SVFIR.h" #include "SVFIR/SVFStatements.h" +#include "SVFIR/SVFType.h" #include "Util/SVFUtil.h" +#include "Util/cJSON.h" #include "lgraph/lgraph_rpc_client.h" #include #include @@ -26,6 +28,9 @@ class SVFStmt; class SVFBasicBlock; class BasicBlockEdge; class BasicBlockGraph; +class CHGraph; +class CHEdge; +class CHNode; class GraphDBClient { private: @@ -60,22 +65,203 @@ class GraphDBClient return connection; } - void processNode(lgraph::RpcClient* connection, ICFGNode* node, const std::string& dbname); bool loadSchema(lgraph::RpcClient* connection, const std::string& filepath, const std::string& dbname); - bool createSubGraph(lgraph::RpcClient* connection, const std::string& graphname); + bool createSubGraph(lgraph::RpcClient* connection, + const std::string& graphname); bool addCallGraphNode2db(lgraph::RpcClient* connection, const CallGraphNode* node, const std::string& dbname); bool addCallGraphEdge2db(lgraph::RpcClient* connection, - const CallGraphEdge* edge, const std::string& dbname); + const CallGraphEdge* edge, + const std::string& dbname); bool addICFGNode2db(lgraph::RpcClient* connection, const ICFGNode* node, const std::string& dbname); bool addICFGEdge2db(lgraph::RpcClient* connection, const ICFGEdge* edge, const std::string& dbname); + /// pasre the directcallsIds/indirectcallsIds string to vector std::vector stringToIds(const std::string& str); + void insertICFG2db(const ICFG* icfg); + void insertCallGraph2db(const CallGraph* callGraph); + void insertPAG2db(const SVFIR* pag); + void insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph); + void insertSVFTypeNodeSet2db(const Set* types, + const Set* stInfos, + std::string& dbname); + + /// @brief parse the CHG and generate the insert statements for CHG nodes and edges + /// @param chg + void insertCHG2db(const CHGraph* chg); + void insertCHNode2db(lgraph::RpcClient* connection, const CHNode* node, const std::string& dbname); + void insertCHEdge2db(lgraph::RpcClient* connection, const CHEdge* edge, const std::string& dbname); + std::string getCHNodeInsertStmt(const CHNode* node); + std::string getCHEdgeInsertStmt(const CHEdge* edge); + + std::string getPAGNodeInsertStmt(const SVFVar* node); + void insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, + const std::string& dbname); + void insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* node, + const std::string& dbname); + void insertBBNode2db(lgraph::RpcClient* connection, + const SVFBasicBlock* node, const std::string& dbname); + void insertBBEdge2db(lgraph::RpcClient* connection, + const BasicBlockEdge* node, const std::string& dbname); + std::string getPAGEdgeInsertStmt(const SVFStmt* edge); + std::string getPAGNodeKindString(const SVFVar* node); + + /// parse ICFGNodes & generate the insert statement for ICFGNodes + std::string getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node); + std::string getIntraICFGNodeInsertStmt(const IntraICFGNode* node); + std::string getInterICFGNodeInsertStmt(const InterICFGNode* node); + std::string getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node); + std::string getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node); + std::string getCallICFGNodeInsertStmt(const CallICFGNode* node); + std::string getRetICFGNodeInsertStmt(const RetICFGNode* node); + std::string getIntraCFGEdgeStmt(const IntraCFGEdge* edge); + std::string getCallCFGEdgeStmt(const CallCFGEdge* edge); + std::string getRetCFGEdgeStmt(const RetCFGEdge* edge); + std::string getICFGNodeKindString(const ICFGNode* node); + + /// parse and generate the node insert statement for SVFType nodes + std::string getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node); + std::string getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node); + std::string getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node); + std::string getSVFSturctTypeNodeInsertStmt(const SVFStructType* node); + std::string getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node); + std::string getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node); + std::string getStInfoNodeInsertStmt(const StInfo* node); + + /// parse and generate the node insert statement for valvar nodes + std::string getSVFVarNodeFieldsStmt(const SVFVar* node); + std::string getValVarNodeFieldsStmt(const ValVar* node); + std::string getValVarNodeInsertStmt(const ValVar* node); + std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node); + /// ConstDataValVar and its sub-class + std::string getConstDataValVarNodeInsertStmt(const ConstDataValVar* node); + std::string getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node); + std::string getConstFPValVarNodeInsertStmt(const ConstFPValVar* node); + std::string getConstIntValVarNodeInsertStmt(const ConstIntValVar* node); + std::string getConstNullPtrValVarNodeInsertStmt( + const ConstNullPtrValVar* node); + // parse and generate the node insert statement for valvar sub-class + std::string getRetValPNNodeInsertStmt(const RetValPN* node); + std::string getVarArgValPNNodeInsertStmt(const VarArgValPN* node); + std::string getDummyValVarNodeInsertStmt(const DummyValVar* node); + std::string getConstAggValVarNodeInsertStmt(const ConstAggValVar* node); + std::string getGlobalValVarNodeInsertStmt(const GlobalValVar* node); + std::string getFunValVarNodeInsertStmt(const FunValVar* node); + std::string getGepValVarNodeInsertStmt(const GepValVar* node); + std::string getArgValVarNodeInsertStmt(const ArgValVar* node); + + /// parse and generate the node insert statement for objvar nodes + std::string getObjVarNodeFieldsStmt(const ObjVar* node); + std::string getObjVarNodeInsertStmt(const ObjVar* node); + std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* node); + std::string getBaseObjNodeInsertStmt(const BaseObjVar* node); + std::string getGepObjVarNodeInsertStmt(const GepObjVar* node); + + /// parse and generate the node insert statement for baseObjVar sub-class + std::string getHeapObjVarNodeInsertStmt(const HeapObjVar* node); + std::string getStackObjVarNodeInsertStmt(const StackObjVar* node); + std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node); + std::string getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node); + std::string getConstNullPtrObjVarNodeInsertStmt( + const ConstNullPtrObjVar* node); + std::string getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node); + std::string getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node); + std::string getDummyObjVarNodeInsertStmt(const DummyObjVar* node); + std::string getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node); + std::string getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node); + std::string getFunObjVarNodeInsertStmt(const FunObjVar* node); + + /// parse and generate the edge insert statement for SVFStmt + std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge); + std::string generateSVFStmtEdgeInsertStmt(const SVFStmt* edge); + /// parse and generate the edge insert statement for AssignStmt & its + /// sub-class + std::string generateAssignStmtFieldsStmt(const AssignStmt* edge); + std::string generateAssignStmtEdgeInsertStmt(const AssignStmt* edge); + std::string generateAddrStmtEdgeInsertStmt(const AddrStmt* edge); + std::string generateCopyStmtEdgeInsertStmt(const CopyStmt* edge); + std::string generateStoreStmtEdgeInsertStmt(const StoreStmt* edge); + std::string generateLoadStmtEdgeInsertStmt(const LoadStmt* edge); + std::string generateGepStmtEdgeInsertStmt(const GepStmt* edge); + std::string generateCallPEEdgeInsertStmt(const CallPE* edge); + std::string generateRetPEEdgeInsertStmt(const RetPE* edge); + std::string generateTDForkPEEdgeInsertStmt(const TDForkPE* edge); + std::string generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge); + /// parse and generate the edge insert statement for MultiOpndStmt & its + /// sub-class + std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge); + std::string generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge); + std::string generatePhiStmtEdgeInsertStmt(const PhiStmt* edge); + std::string generateSelectStmtEndgeInsertStmt(const SelectStmt* edge); + std::string generateCmpStmtEdgeInsertStmt(const CmpStmt* edge); + std::string generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge); + std::string genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge); + std::string generateBranchStmtEdgeInsertStmt(const BranchStmt* edge); + + /// parse and generate the insert statement for BasicBlockGraph + std::string getBBNodeInsertStmt(const SVFBasicBlock* node); + std::string getBBEdgeInsertStmt(const BasicBlockEdge* edge); + + + cJSON* queryFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string queryStatement); + /// read SVFType from DB + void readSVFTypesFromDB(lgraph::RpcClient* connection, + const std::string& dbname, SVFIR* pag); + void addSVFTypeNodeFromDB(lgraph::RpcClient* connection, + const std::string& dbname, SVFIR* pag); + + /// read BasicBlockGraph from DB + void readBasicBlockGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname); + void readBasicBlockNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); + void readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); + + /// read ICFGNodes & ICFGEdge from DB + ICFG* buildICFGFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); + /// ICFGNodes + void readICFGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, ICFG* icfg, SVFIR* pag); + ICFGNode* parseGlobalICFGNodeFromDBResult(const cJSON* node); + ICFGNode* parseFunEntryICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + ICFGNode* parseFunExitICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + ICFGNode* parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + ICFGNode* parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + ICFGNode* parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + void updateRetPE4RetCFGEdge(); + void updateCallPEs4CallCFGEdge(); + + /// ICFGEdges + void readICFGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, ICFG* icfg, SVFIR* pag); + ICFGEdge* parseIntraCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); + ICFGEdge* parseCallCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); + ICFGEdge* parseRetCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); + + // read CallGraph Nodes & CallGraphEdge from DB + CallGraph* buildCallGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); + CallGraphNode* parseCallGraphNodeFromDB(const cJSON* node); + CallGraphEdge* parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* pag, CallGraph* callGraph); + void readCallGraphNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, CallGraph* callGraph); + void readCallGraphEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag, CallGraph* callGraph); + + /// read PAGNodes from DB + void readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag); + void initialSVFPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); + void updateSVFPAGNodesAttributesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag); + void updatePAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); + void updateSVFValVarAtrributes(cJSON* properties, ValVar* var, SVFIR* pag); + void updateGepValVarAttributes(cJSON* properties, GepValVar* var, SVFIR* pag); + void updateSVFBaseObjVarAtrributes(cJSON* properties, BaseObjVar* var, SVFIR* pag); + void updateFunObjVarAttributes(cJSON* properties, FunObjVar* var, SVFIR* pag); + void loadSVFPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); + void readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag); + void parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap); + void parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes); + + ObjTypeInfo* parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag); + template std::string extractNodesIds(const Container& nodes) { @@ -97,6 +283,17 @@ class GraphDBClient return nodesIds.str(); } + std::string extractFuncVectors2String(std::vector> vec) { + std::ostringstream oss; + for (size_t i = 0; i < vec.size(); ++i) { + oss << "{" << extractNodesIds(vec[i]) << "}"; + if (i + 1 != vec.size()) { + oss << ","; + } + } + return oss.str(); + } + template std::string extractEdgesIds(const Container& edges) { @@ -139,6 +336,45 @@ class GraphDBClient return idxVecStr.str(); } + template + Container parseElements2Container(std::string& str) + { + str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); + str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); + Container idxVec; + std::istringstream ss(str); + std::string token; + + while (std::getline(ss, token, ',')) + { + if constexpr (std::is_same::value) + { + if constexpr (std::is_same>::value) + idxVec.push_back(std::stoi(token)); + else + idxVec.insert(std::stoi(token)); + } + else if constexpr (std::is_same::value) + { + if constexpr (std::is_same>::value) + idxVec.push_back(static_cast(std::stoul(token))); + else + idxVec.insert(static_cast(std::stoul(token))); + } + else + { + if constexpr (std::is_same>::value) + idxVec.push_back(std::stof(token)); + else + idxVec.insert(std::stof(token)); + } + } + + return idxVec; + } + template std::string extractSVFTypes(const Container& types) { @@ -146,20 +382,90 @@ class GraphDBClient { return ""; } + std::ostringstream typesStr; auto it = types.begin(); - - typesStr << (*it)->toString(); + + + typesStr << "{" << (*it)->toString() << "}"; ++it; - + for (; it != types.end(); ++it) { - typesStr << "," << (*it)->toString(); + typesStr << "," << "{" << (*it)->toString() << "}"; } - + return typesStr.str(); } + template + Container parseElementsToSVFTypeContainer( + std::string& str, const Map& typeMap) + { + str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); + str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); + + Container resultContainer; + + size_t pos = 0; + while ((pos = str.find('{')) != std::string::npos) + { + size_t endPos = str.find('}', pos); + if (endPos == std::string::npos) + { + SVFUtil::outs() << "Warning: Mismatched brackets in input string\n"; + break; + } + + std::string token = str.substr(pos + 1, endPos - pos - 1); + + token.erase(token.find_last_not_of(" \t") + 1); + token.erase(0, token.find_first_not_of(" \t")); + + auto it = typeMap.find(token); + if (it != typeMap.end()) + { + resultContainer.insert(resultContainer.end(), it->second); + } + else + { + SVFUtil::outs() + << "Warning: No matching SVFType found for token '" << token + << "'\n"; + } + + str = str.substr(endPos + 1); + } + + return resultContainer; + } + + std::vector parseSVFTypes(std::string typesStr) + { + typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\n'), + typesStr.end()); + typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\r'), + typesStr.end()); + std::vector result; + std::stringstream ss(typesStr); + std::string token; + + while (std::getline(ss, token, ',')) + { + if (!token.empty() && token.front() == '{') + { + token.erase(0, 1); + } + if (!token.empty() && token.back() == '}') + { + token.erase(token.size() - 1, 1); + } + result.push_back(token); + } + + return result; + } + template std::string extractFldIdx2TypeMap(const MapType& fldIdx2TypeMap) { @@ -167,20 +473,63 @@ class GraphDBClient { return ""; } + std::ostringstream mapStr; auto it = fldIdx2TypeMap.begin(); - - mapStr << it->first << ":" << it->second->toString(); + + mapStr << "{" << it->first << ":" << it->second->toString() << "}"; ++it; - + for (; it != fldIdx2TypeMap.end(); ++it) { - mapStr << "," << it->first << ":" << it->second->toString(); + mapStr << ",{" << it->first << ":" << it->second->toString() << "}"; } - + return mapStr.str(); } + template + MapType parseStringToFldIdx2TypeMap(const std::string& str, const Map& typeMap) + { + MapType resultMap; + + std::string cleanedStr = str; + cleanedStr.erase(0, cleanedStr.find_first_not_of(" \t")); + cleanedStr.erase(cleanedStr.find_last_not_of(" \t") + 1); + + size_t startPos = 0; + size_t openBracePos = cleanedStr.find('{', startPos); + + while (openBracePos != std::string::npos) { + size_t closeBracePos = cleanedStr.find('}', openBracePos); + if (closeBracePos == std::string::npos) { + break; + } + + std::string token = cleanedStr.substr(openBracePos + 1, closeBracePos - openBracePos - 1); + + size_t colonPos = token.find(':'); + if (colonPos != std::string::npos) { + std::string keyStr = token.substr(0, colonPos); + std::string typeStr = token.substr(colonPos + 1); + + u32_t key = static_cast(std::stoi(keyStr)); + + auto it = typeMap.find(typeStr); + if (it != typeMap.end()) { + resultMap[key] = it->second; + } else { + SVFUtil::outs() << "Warning: No matching SVFType found for type: " << typeStr << "\n"; + } + } + + startPos = closeBracePos + 1; + openBracePos = cleanedStr.find('{', startPos); + } + + return resultMap; + } + template std::string extractLabelMap2String(const LabelMapType& labelMap) { @@ -189,20 +538,46 @@ class GraphDBClient return ""; } std::ostringstream mapStr; - + for (auto it = labelMap->begin(); it != labelMap->end(); ++it) { if (it != labelMap->begin()) { mapStr << ","; } - mapStr << (it->first ? std::to_string(it->first->getId()) : "NULL") + mapStr << (it->first ? std::to_string(it->first->getId()) : "NULL") << ":" << std::to_string(it->second); } - + return mapStr.str(); } + template + MapType parseLabelMapFromString(const std::string& str) + { + MapType result; + if (str.empty()) return result; + + std::stringstream ss(str); + std::string pairStr; + + while (std::getline(ss, pairStr, ',')) + { + size_t colonPos = pairStr.find(':'); + if (colonPos == std::string::npos) continue; + + std::string keyStr = pairStr.substr(0, colonPos); + std::string valStr = pairStr.substr(colonPos + 1); + + int key = (keyStr == "NULL") ? -1 : std::stoi(keyStr); + int val = std::stoi(valStr); + + result[key] = val; + } + + return result; + } + template std::string extractBBsMapWithSet2String(const BBsMapWithSetType& bbsMap) { @@ -223,6 +598,50 @@ class GraphDBClient return mapStr.str(); } + template + MapType parseBBsMapFromString(const std::string& str) + { + MapType result; + + using KeyType = typename MapType::key_type; + using ValueContainer = typename MapType::mapped_type; + using ValueType = typename ValueContainer::value_type; + + size_t pos = 0; + while ((pos = str.find('[', pos)) != std::string::npos) + { + size_t end = str.find(']', pos); + if (end == std::string::npos) break; + + std::string block = str.substr(pos + 1, end - pos - 1); // earse [] + pos = end + 1; + + size_t colonPos = block.find(':'); + if (colonPos == std::string::npos) continue; + + std::string keyStr = block.substr(0, colonPos); + std::string valuesStr = block.substr(colonPos + 1); + + KeyType key = static_cast(std::stoi(keyStr)); + ValueContainer values; + + if (!valuesStr.empty()) + { + std::stringstream ss(valuesStr); + std::string token; + while (std::getline(ss, token, ',')) + { + if (!token.empty()) + values.insert(values.end(), static_cast(std::stoi(token))); + } + } + + result[key] = values; + } + + return result; + } + template std::string extractBBsMap2String(const BBsMapType& bbsMap) { @@ -231,22 +650,54 @@ class GraphDBClient return ""; } std::ostringstream mapStr; - for (const auto& pair : *bbsMap) { - if (mapStr.tellp() != std::streampos(0)) { + for (const auto& pair : *bbsMap) + { + if (mapStr.tellp() != std::streampos(0)) + { mapStr << ","; } - if (pair.first != nullptr && pair.second != nullptr) { + if (pair.first != nullptr && pair.second != nullptr) + { mapStr << pair.first->getId() << ":" << pair.second->getId(); } - else if (pair.first == nullptr) { + else if (pair.first == nullptr) + { mapStr << "NULL:" << pair.second->getId(); } - else if (pair.second == nullptr) { - mapStr << pair.first->getId() << ":NULL"; + else if (pair.second == nullptr) + { + mapStr << pair.first->getId() << ":NULL"; } } return mapStr.str(); } + + + template + MapType parseBB2PiMapFromString(const std::string& str) + { + MapType result; + if (str.empty()) return result; + + std::stringstream ss(str); + std::string pairStr; + + while (std::getline(ss, pairStr, ',')) + { + size_t colonPos = pairStr.find(':'); + if (colonPos == std::string::npos) continue; + + std::string keyStr = pairStr.substr(0, colonPos); + std::string valStr = pairStr.substr(colonPos + 1); + + int key = (keyStr == "NULL") ? -1 : std::stoi(keyStr); + int val = (valStr == "NULL") ? -1 : std::stoi(valStr); + + result[key] = val; + } + + return result; + } template std::string pagEdgeToSetMapTyToString(const MapType& map) @@ -282,16 +733,18 @@ class GraphDBClient } /// Convert IdxOperandPairs to string - std::string IdxOperandPairsToString(const AccessPath::IdxOperandPairs* idxOperandPairs) const + std::string IdxOperandPairsToString( + const AccessPath::IdxOperandPairs* idxOperandPairs) const { if (idxOperandPairs->empty()) { return ""; } - + std::ostringstream oss; oss << "["; - for (auto it = idxOperandPairs->begin(); it != idxOperandPairs->end(); ++it) + for (auto it = idxOperandPairs->begin(); it != idxOperandPairs->end(); + ++it) { if (it != idxOperandPairs->begin()) { @@ -303,21 +756,68 @@ class GraphDBClient return oss.str(); } - std::string IdxOperandPairToString(const AccessPath::IdxOperandPair& pair) const + std::string IdxOperandPairToString( + const AccessPath::IdxOperandPair& pair) const { std::ostringstream oss; if (nullptr != pair.first && nullptr != pair.second) { - oss << "{" << pair.first->getId() << ", " << pair.second->toString() << "}"; + oss << "{" << pair.first->getId() << ", " << pair.second->toString() + << "}"; return oss.str(); - } else if (nullptr == pair.second) + } + else if (nullptr == pair.second) { oss << "{" << pair.first->getId() << ", NULL}"; } return ""; } - std::string extractSuccessorsPairSet2String(const BranchStmt::SuccAndCondPairVec* vec) + std::vector> parseIdxOperandPairsString(const std::string& str) + { + std::vector> result; + + if (str.empty() || str == "[]") + { + return result; + } + + size_t pos = 0; + std::string content = str.substr(1, str.size() - 2); // remove the outter [] + + while ((pos = content.find('{')) != std::string::npos) + { + size_t end = content.find('}', pos); + if (end == std::string::npos) + break; + + std::string pairStr = + content.substr(pos + 1, end - pos - 1); // extract the pair content + content = content.substr(end + 1); //processing the rest + + size_t comma = pairStr.find(','); + if (comma == std::string::npos) + continue; + + std::string idStr = pairStr.substr(0, comma); + std::string operandStr = pairStr.substr(comma + 1); + + // erase the spaces + idStr.erase(std::remove_if(idStr.begin(), idStr.end(), ::isspace), + idStr.end()); + operandStr.erase( + std::remove_if(operandStr.begin(), operandStr.end(), ::isspace), + operandStr.end()); + + int id = std::stoi(idStr); + result.emplace_back(id, operandStr); + } + + return result; + } + + std::string extractSuccessorsPairSet2String( + const BranchStmt::SuccAndCondPairVec* vec) { std::ostringstream oss; for (auto it = vec->begin(); it != vec->end(); ++it) @@ -326,140 +826,49 @@ class GraphDBClient { oss << ","; } - oss << (*it).first->getId()<<":"<< std::to_string((*it).second); + oss << (*it).first->getId() << ":" << std::to_string((*it).second); } return oss.str(); } - /// parse and extract the directcallsIds/indirectcallsIds vector - - /// parse ICFGNodes & generate the insert statement for ICFGNodes - std::string getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node); - - std::string getIntraICFGNodeInsertStmt(const IntraICFGNode* node); - - std::string getInterICFGNodeInsertStmt(const InterICFGNode* node); - - std::string getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node); - - std::string getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node); - - std::string getCallICFGNodeInsertStmt(const CallICFGNode* node); - - std::string getRetICFGNodeInsertStmt(const RetICFGNode* node); - - std::string getIntraCFGEdgeStmt(const IntraCFGEdge* edge); - - std::string getCallCFGEdgeStmt(const CallCFGEdge* edge); - - std::string getRetCFGEdgeStmt(const RetCFGEdge* edge); - - std::string getICFGNodeKindString(const ICFGNode* node); - - void insertICFG2db(const ICFG* icfg); - - void insertCallGraph2db(const CallGraph* callGraph); - - void insertPAG2db(const SVFIR* pag); - - void insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph); - - void insertSVFTypeNodeSet2db(const Set* types,const Set* stInfos, std::string& dbname); - - std::string getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node); - - std::string getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node); - - std::string getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node); - - std::string getSVFSturctTypeNodeInsertStmt(const SVFStructType* node); - - std::string getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node); - - std::string getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node); - - std::string getStInfoNodeInsertStmt(const StInfo* node); - - /// parse and generate the node insert statement for valvar nodes - std::string getSVFVarNodeFieldsStmt(const SVFVar* node); - std::string getValVarNodeFieldsStmt(const ValVar* node); - std::string getValVarNodeInsertStmt(const ValVar* node); - std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node); - /// ConstDataValVar and its sub-class - std::string getConstDataValVarNodeInsertStmt(const ConstDataValVar* node); - std::string getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node); - std::string getConstFPValVarNodeInsertStmt(const ConstFPValVar* node); - std::string getConstIntValVarNodeInsertStmt(const ConstIntValVar* node); - std::string getConstNullPtrValVarNodeInsertStmt(const ConstNullPtrValVar* node); - // parse and generate the node insert statement for valvar sub-class - std::string getRetValPNNodeInsertStmt(const RetValPN* node); - std::string getVarArgValPNNodeInsertStmt(const VarArgValPN* node); - std::string getDummyValVarNodeInsertStmt(const DummyValVar* node); - std::string getConstAggValVarNodeInsertStmt(const ConstAggValVar* node); - std::string getGlobalValVarNodeInsertStmt(const GlobalValVar* node); - std::string getFunValVarNodeInsertStmt(const FunValVar* node); - std::string getGepValVarNodeInsertStmt(const GepValVar* node); - std::string getArgValVarNodeInsertStmt(const ArgValVar* node); - - /// parse and generate the node insert statement for objvar nodes - std::string getObjVarNodeFieldsStmt(const ObjVar* node); - std::string getObjVarNodeInsertStmt(const ObjVar* node); - std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* node); - std::string getBaseObjNodeInsertStmt(const BaseObjVar* node); - std::string getGepObjVarNodeInsertStmt(const GepObjVar* node); - - /// parse and generate the node insert statement for baseObjVar sub-class - std::string getHeapObjVarNodeInsertStmt(const HeapObjVar* node); - std::string getStackObjVarNodeInsertStmt(const StackObjVar* node); - std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node); - std::string getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node); - std::string getConstNullPtrObjVarNodeInsertStmt(const ConstNullPtrObjVar* node); - std::string getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node); - std::string getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node); - std::string getDummyObjVarNodeInsertStmt(const DummyObjVar* node); - std::string getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node); - std::string getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node); - std::string getFunObjVarNodeInsertStmt(const FunObjVar* node); - - - - /// parse and generate the edge insert statement for SVFStmt - std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge); - std::string generateSVFStmtEdgeInsertStmt(const SVFStmt* edge); - /// parse and generate the edge insert statement for AssignStmt & its sub-class - std::string generateAssignStmtFieldsStmt(const AssignStmt* edge); - std::string generateAssignStmtEdgeInsertStmt(const AssignStmt* edge); - std::string generateAddrStmtEdgeInsertStmt(const AddrStmt* edge); - std::string generateCopyStmtEdgeInsertStmt(const CopyStmt* edge); - std::string generateStoreStmtEdgeInsertStmt(const StoreStmt* edge); - std::string generateLoadStmtEdgeInsertStmt(const LoadStmt* edge); - std::string generateGepStmtEdgeInsertStmt(const GepStmt* edge); - std::string generateCallPEEdgeInsertStmt(const CallPE* edge); - std::string generateRetPEEdgeInsertStmt(const RetPE* edge); - std::string generateTDForkPEEdgeInsertStmt(const TDForkPE* edge); - std::string generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge); - /// parse and generate the edge insert statement for MultiOpndStmt & its sub-class - std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge); - std::string generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge); - std::string generatePhiStmtEdgeInsertStmt(const PhiStmt* edge); - std::string generateSelectStmtEndgeInsertStmt(const SelectStmt* edge); - std::string generateCmpStmtEdgeInsertStmt(const CmpStmt* edge); - std::string generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge); - - std::string genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge); - std::string generateBranchStmtEdgeInsertStmt(const BranchStmt* edge); + std::vector> parseSuccessorsPairSetFromString(const std::string& str) + { + std::vector> result; + if (str.empty()) + return result; + + std::stringstream ss(str); + std::string pairStr; + + while (std::getline(ss, pairStr, ',')) { + size_t colonPos = pairStr.find(':'); + if (colonPos != std::string::npos) { + int first = std::stoi(pairStr.substr(0, colonPos)); + s32_t second = static_cast(std::stoi(pairStr.substr(colonPos + 1))); + result.emplace_back(first, second); + } + } + + return result; + } + int parseBBId(const std::string& str) { + size_t pos = str.find(':'); + int number = std::stoi(str.substr(0, pos)); + return number; + } - std::string getPAGNodeInsertStmt(const SVFVar* node); - void insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, const std::string& dbname); - void insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* node, const std::string& dbname); - void insertBBNode2db(lgraph::RpcClient* connection, const SVFBasicBlock* node, const std::string& dbname); - void insertBBEdge2db(lgraph::RpcClient* connection, const BasicBlockEdge* node, const std::string& dbname); - std::string getBBNodeInsertStmt (const SVFBasicBlock* node); - std::string getBBEdgeInsertStmt(const BasicBlockEdge* edge); - std::string getPAGEdgeInsertStmt(const SVFStmt* edge); - std::string getPAGNodeKindString(const SVFVar* node); + std::pair parseBBIdPair(const std::string& idStr) { + size_t colonPos = idStr.find(':'); + if (colonPos == std::string::npos) { + return std::make_pair(-1, -1); + } + + int functionId = std::stoi(idStr.substr(0, colonPos)); + int bbId = std::stoi(idStr.substr(colonPos + 1)); + return std::make_pair(functionId, bbId); + } }; } // namespace SVF diff --git a/svf/include/SVFIR/ObjTypeInfo.h b/svf/include/SVFIR/ObjTypeInfo.h index 0138decee..4e6158aad 100644 --- a/svf/include/SVFIR/ObjTypeInfo.h +++ b/svf/include/SVFIR/ObjTypeInfo.h @@ -42,6 +42,14 @@ namespace SVF class ObjTypeInfo { friend class SymbolTableBuilder; + friend class GraphDBClient; + +protected: +/// Constructors +ObjTypeInfo(const SVFType* t, u32_t flags, u32_t max, u32_t elemNum, u32_t byteSize) : type(t), flags(flags), maxOffsetLimit(max), elemNum(elemNum), byteSize(byteSize) +{ + assert(t && "no type information for this object?"); +} public: typedef enum diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index ab9334417..6cf95fdee 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -46,6 +46,7 @@ class SVFIR : public IRGraph friend class PAGBuilderFromFile; friend class TypeBasedHeapCloning; friend class BVDataPTAImpl; + friend class GraphDBClient; public: typedef Set CallSiteSet; @@ -500,6 +501,59 @@ class SVFIR : public IRGraph /// Print SVFIR void print(); +protected: + /// Add a value (pointer) node + inline NodeID addValNodeFromDB(ValVar* node) + { + assert(node && "node cannot be nullptr."); + if (hasGNode(node->getId())) + { + ValVar* valvar = SVFUtil::cast(getGNode(node->getId())); + valvar->updateSVFValVar(node->getType(), node->getICFGNode()); + return valvar->getId(); + } + return addNode(node); + } + /// Add a memory obj node + inline NodeID addObjNodeFromDB(ObjVar* node) + { + assert(node && "node cannot be nullptr."); + if (hasGNode(node->getId())) + { + ObjVar* objVar = SVFUtil::cast(getGNode(node->getId())); + objVar->updateObjVar(node->getType()); + return objVar->getId(); + } + return addNode(node); + } + + inline NodeID addInitValNode(ValVar* node) + { + return addValNode(node); + } + + inline NodeID addBaseObjNode(BaseObjVar* node) + { + memToFieldsMap[node->getId()].set(node->getId()); + return addObjNode(node); + } + + inline NodeID addDummyObjNode(DummyObjVar* node) + { + if (idToObjTypeInfoMap().find(node->getId()) == idToObjTypeInfoMap().end()) + { + ObjTypeInfo* ti = node->getTypeInfo(); + idToObjTypeInfoMap()[node->getId()] = ti; + return addObjNode(node); + } + else + { + return addObjNode(node); + } + } + + void addGepObjNode(GepObjVar* gepObj); + private: /// Map a SVFStatement type to a set of corresponding SVF statements @@ -524,6 +578,12 @@ class SVFIR : public IRGraph funEntryBlockNode->addFormalParms(arg); funArgsListMap[fun].push_back(arg); } + + inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, FunObjVar* fun, const SVFVar* arg) + { + funEntryBlockNode->addFormalParms(arg); + funArgsListMap[fun].push_back(arg); + } /// Add function returns inline void addFunRet(const FunObjVar* fun, const SVFVar* ret) { @@ -531,6 +591,12 @@ class SVFIR : public IRGraph funExitBlockNode->addFormalRet(ret); funRetMap[fun] = ret; } + + inline void addFunRet(FunExitICFGNode* funExitBlockNode, FunObjVar* fun, const SVFVar* ret) + { + funExitBlockNode->addFormalRet(ret); + funRetMap[fun] = ret; + } /// Add callsite arguments inline void addCallSiteArgs(CallICFGNode* callBlockNode,const ValVar* arg) { @@ -795,36 +861,49 @@ class SVFIR : public IRGraph //@{ /// Add Address edge AddrStmt* addAddrStmt(NodeID src, NodeID dst); + void addAddrStmt(AddrStmt* edge); /// Add Copy edge CopyStmt* addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type); + void addCopyStmt(CopyStmt* edge); /// Add phi node information PhiStmt* addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred); + void addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst); /// Add SelectStmt SelectStmt* addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond); + void addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge CmpStmt* addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predict); + void addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge BinaryOPStmt* addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t opcode); + void addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add Unary edge UnaryOPStmt* addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode); + void addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add BranchStmt BranchStmt* addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs); + void addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst); /// Add Load edge LoadStmt* addLoadStmt(NodeID src, NodeID dst); + void addLoadStmt(LoadStmt* edge); /// Add Store edge StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val); + void addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst); /// Add Call edge CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunEntryICFGNode* entry); + void addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst); /// Add Return edge RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunExitICFGNode* exit); + void addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst); /// Add Gep edge GepStmt* addGepStmt(NodeID src, NodeID dst, const AccessPath& ap, bool constGep); + void addGepStmt(GepStmt* edge); /// Add Offset(Gep) edge GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap); /// Add Variant(Gep) edge diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index c26e1526f..0b1c191b3 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -51,6 +51,11 @@ class SVFBasicBlock; typedef GenericEdge GenericPAGEdgeTy; class SVFStmt : public GenericPAGEdgeTy { + friend class AssignStmt; + friend class MultiOpndStmt; + friend class UnaryOPStmt; + friend class BranchStmt; + friend class GraphDBClient; public: /// Types of SVFIR statements @@ -89,6 +94,38 @@ class SVFStmt : public GenericPAGEdgeTy { } + SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, bool real = true); + + inline void setBasicBlock(const SVFBasicBlock* bb) + { + basicBlock = bb; + } + + inline void setCallEdgeLabelCounter(u64_t counter) + { + callEdgeLabelCounter = counter; + } + + inline void setStoreEdgeLabelCounter(u64_t counter) + { + storeEdgeLabelCounter = counter; + } + + inline void setMultiOpndLabelCounter(u64_t counter) + { + multiOpndLabelCounter = counter; + } + + static inline void addInst2Labeled(const ICFGNode* cs, u32_t label) + { + inst2LabelMap.emplace(cs, label); + } + + static inline void addVar2Labeled(const SVFVar* var, u32_t label) + { + var2LabelMap.emplace(var, label); + } + public: // static u32_t totalEdgeNum; ///< Total edge number @@ -258,6 +295,14 @@ class SVFStmt : public GenericPAGEdgeTy */ class AssignStmt : public SVFStmt { + friend class GraphDBClient; + friend class AddrStmt; + friend class CopyStmt; + friend class StoreStmt; + friend class LoadStmt; + friend class GepStmt; + friend class CallPE; + friend class RetPE; private: AssignStmt(); ///< place holder @@ -271,6 +316,7 @@ class AssignStmt : public SVFStmt protected: /// constructor AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k) : SVFStmt(s, d, k) {} + AssignStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode) : SVFStmt(s, d, k, eid, value, icfgNode) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -330,6 +376,10 @@ class AssignStmt : public SVFStmt */ class AddrStmt: public AssignStmt { + friend class GraphDBClient; + +protected: + AddrStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode): AssignStmt(s, d, k, eid, value, icfgNode) {} private: AddrStmt(const AddrStmt&); ///< place holder @@ -378,6 +428,11 @@ class AddrStmt: public AssignStmt class CopyStmt: public AssignStmt { + friend class GraphDBClient; + +protected: + CopyStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t copyKind, ICFGNode* icfgNode): AssignStmt(s, d, k, eid, value, icfgNode), copyKind(copyKind) {} + private: CopyStmt(const CopyStmt&); ///< place holder void operator=(const CopyStmt&); ///< place holder @@ -462,6 +517,10 @@ class CopyStmt: public AssignStmt */ class StoreStmt: public AssignStmt { + friend class GraphDBClient; + +protected: + StoreStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode); private: StoreStmt(const StoreStmt&); ///< place holder @@ -495,6 +554,10 @@ class StoreStmt: public AssignStmt */ class LoadStmt: public AssignStmt { + friend class GraphDBClient; + +protected: + LoadStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode): AssignStmt(s, d, k, eid, value, icfgNode) {} private: LoadStmt(const LoadStmt&); ///< place holder @@ -528,6 +591,12 @@ class LoadStmt: public AssignStmt */ class GepStmt: public AssignStmt { + friend class GraphDBClient; + +protected: + GepStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const AccessPath& ap, bool varfld = false) + : AssignStmt(s, d, k, eid, value, icfgNode), ap(ap), variantField(varfld){} + private: GepStmt(const GepStmt &); ///< place holder @@ -609,6 +678,13 @@ class GepStmt: public AssignStmt */ class CallPE: public AssignStmt { + friend class GraphDBClient; + friend class TDForkPE; + +protected: + CallPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunEntryICFGNode* entry); + private: CallPE(const CallPE&); ///< place holder @@ -664,6 +740,13 @@ class CallPE: public AssignStmt */ class RetPE: public AssignStmt { + friend class GraphDBClient; + friend class TDJoinPE; + +protected: + RetPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunExitICFGNode* exit); + private: RetPE(const RetPE&); ///< place holder @@ -719,6 +802,13 @@ class RetPE: public AssignStmt */ class MultiOpndStmt : public SVFStmt { + friend class GraphDBClient; + friend class PhiStmt; + friend class SelectStmt; + friend class CmpStmt; + friend class BinaryOPStmt; + + public: typedef std::vector OPVars; @@ -736,6 +826,8 @@ class MultiOpndStmt : public SVFStmt OPVars opVars; /// Constructor, only used by subclasses but not external users MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k); + MultiOpndStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const OPVars& opnds) + : SVFStmt(s, d, k, eid, value, icfgNode), opVars(opnds) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -797,6 +889,11 @@ class MultiOpndStmt : public SVFStmt */ class PhiStmt: public MultiOpndStmt { + friend class GraphDBClient; + +protected: + PhiStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const OPVars& opnds) + : MultiOpndStmt(s, d, k, eid, value, icfgNode, opnds) {} public: typedef std::vector OpICFGNodeVec; @@ -843,6 +940,13 @@ class PhiStmt: public MultiOpndStmt "Numbers of operands and their ICFGNodes are not consistent?"); } + void setOpICFGNodeVec(OpICFGNodeVec& icfgNodes) + { + assert(opVars.size() == icfgNodes.size() && + "Numbers of operands and their ICFGNodes are not consistent?"); + opICFGNodes = icfgNodes; + } + inline const OpICFGNodeVec* getOpICFGNodeVec() const { return &opICFGNodes; @@ -866,6 +970,11 @@ class PhiStmt: public MultiOpndStmt */ class SelectStmt: public MultiOpndStmt { + friend class GraphDBClient; + +protected: + SelectStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, SVFVar* condition, ICFGNode* icfgNode, const OPVars& opnds); + private: SelectStmt(const SelectStmt&); ///< place holder @@ -917,6 +1026,10 @@ class SelectStmt: public MultiOpndStmt */ class CmpStmt: public MultiOpndStmt { + friend class GraphDBClient; + +protected: + CmpStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t predicate, ICFGNode* icfgNode, const OPVars& opnds); private: CmpStmt(const CmpStmt&); ///< place holder @@ -999,6 +1112,10 @@ class CmpStmt: public MultiOpndStmt */ class BinaryOPStmt: public MultiOpndStmt { + friend class GraphDBClient; + +protected: + BinaryOPStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t opcode, ICFGNode* icfgNode, const OPVars& opnds); private: BinaryOPStmt(const BinaryOPStmt&); ///< place holder @@ -1065,6 +1182,11 @@ class BinaryOPStmt: public MultiOpndStmt */ class UnaryOPStmt: public SVFStmt { + friend class GraphDBClient; + +protected: + UnaryOPStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t opcode, ICFGNode* icfgNode) + : SVFStmt(s, d, k, eid, value, icfgNode), opcode(opcode) {} private: UnaryOPStmt(const UnaryOPStmt&); ///< place holder @@ -1128,6 +1250,7 @@ class UnaryOPStmt: public SVFStmt */ class BranchStmt: public SVFStmt { + friend class GraphDBClient; public: typedef std::vector> SuccAndCondPairVec; @@ -1144,6 +1267,10 @@ class BranchStmt: public SVFStmt const SVFVar* cond; const SVFVar* brInst; +protected: +BranchStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, SuccAndCondPairVec& successors, const SVFVar* cond,const SVFVar* brInst, ICFGNode* icfgNode) + : SVFStmt(s, d, k, eid, value, icfgNode), successors(successors), cond(cond), brInst(brInst){} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -1214,6 +1341,11 @@ class BranchStmt: public SVFStmt */ class TDForkPE: public CallPE { + friend class GraphDBClient; + +protected: + TDForkPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunEntryICFGNode* entry): CallPE(s, d, k, eid, value, icfgNode, call, entry) {} private: TDForkPE(const TDForkPE&); ///< place holder @@ -1251,6 +1383,12 @@ class TDForkPE: public CallPE */ class TDJoinPE: public RetPE { + friend class GraphDBClient; + +protected: + TDJoinPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunExitICFGNode* exit): RetPE(s, d, k, eid, value, icfgNode, call, exit) {} + private: TDJoinPE(const TDJoinPE&); ///< place holder diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index 34794ff5e..9e03d78da 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -77,6 +77,14 @@ class StInfo explicit StInfo(u32_t s) : stride(s), numOfFlattenElements(s), numOfFlattenFields(s) { + } + + StInfo (u32_t id, std::vector fldIdxVec, std::vector elemIdxVec, Map fldIdx2TypeMap, + std::vector finfo,u32_t stride,u32_t numOfFlattenElements,u32_t numOfFlattenFields, std::vector flattenElementTypes ) + :StInfoId(id), fldIdxVec(fldIdxVec), elemIdxVec(elemIdxVec), fldIdx2TypeMap(fldIdx2TypeMap), finfo(finfo), stride(stride), + numOfFlattenElements(numOfFlattenElements), numOfFlattenFields(numOfFlattenFields), flattenElementTypes(flattenElementTypes) + { + } /// Destructor ~StInfo() = default; @@ -164,6 +172,8 @@ class StInfo { return stride; } + + std::string toDBString() const; }; class SVFType @@ -193,12 +203,22 @@ class SVFType return svfPtrTy; } + inline static void setSVFPtrType(SVFType* ptrTy) + { + svfPtrTy = ptrTy; + } + inline static SVFType* getSVFInt8Type() { assert(svfI8Ty && "int8 type not set?"); return svfI8Ty; } + inline static void setSVFInt8Type(SVFType* i8Ty) + { + svfI8Ty = i8Ty; + } + private: static SVFType* svfPtrTy; ///< ptr type @@ -295,12 +315,30 @@ class SVFPointerType : public SVFType { } + SVFPointerType(u32_t id, u32_t byteSize, bool isSingleValTy) + : SVFType(isSingleValTy, SVFPointerTy, id, byteSize) + { + + } + static inline bool classof(const SVFType* node) { return node->getKind() == SVFPointerTy; } void print(std::ostream& os) const override; + + std::string toDBString() const + { + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFPointerType {id:" + std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + "})"; + return queryStatement; + } }; class SVFIntegerType : public SVFType @@ -311,6 +349,11 @@ class SVFIntegerType : public SVFType public: SVFIntegerType(u32_t i, u32_t byteSize = 1) : SVFType(true, SVFIntegerTy, i, byteSize) {} + SVFIntegerType(u32_t i, u32_t byteSize, bool isSingleValTy,short signAndWidth) + : SVFType(isSingleValTy, SVFIntegerTy, i, byteSize) + { + this->signAndWidth = signAndWidth; + } static inline bool classof(const SVFType* node) { return node->getKind() == SVFIntegerTy; @@ -332,6 +375,19 @@ class SVFIntegerType : public SVFType { return signAndWidth < 0; } + + std::string toDBString() const + { + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFIntegerType {id:" + std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + + ", single_and_width:" + std::to_string(getSignAndWidth()) + "})"; + return queryStatement; + } }; class SVFFunctionType : public SVFType @@ -348,6 +404,11 @@ class SVFFunctionType : public SVFType { } + SVFFunctionType(u32_t id, bool svt, u32_t byteSize) + : SVFType(svt, SVFFunctionTy, id, byteSize) + { + } + static inline bool classof(const SVFType* node) { return node->getKind() == SVFFunctionTy; @@ -357,18 +418,29 @@ class SVFFunctionType : public SVFType return retTy; } + const void setReturnType(const SVFType* rt) + { + retTy = rt; + } + const std::vector& getParamTypes() const { return params; } - bool isVarArg() const { return varArg; } + void addParamType(const SVFType* type) + { + params.push_back(type); + } + void print(std::ostream& os) const override; + + std::string toDBString() const; }; class SVFStructType : public SVFType @@ -385,6 +457,8 @@ class SVFStructType : public SVFType { } + SVFStructType(u32_t i, bool svt, u32_t byteSize, std::string name) : SVFType(svt, SVFStructTy, i, byteSize),name(name) {} + static inline bool classof(const SVFType* node) { return node->getKind() == SVFStructTy; @@ -415,6 +489,13 @@ class SVFStructType : public SVFType { return fields; } + + void addFieldsType(const SVFType* type) + { + fields.push_back(type); + } + + std::string toDBString() const; }; class SVFArrayType : public SVFType @@ -428,6 +509,11 @@ class SVFArrayType : public SVFType SVFArrayType(u32_t i, u32_t byteSize = 1) : SVFType(false, SVFArrayTy, i, byteSize), numOfElement(0), typeOfElement(nullptr) { + } + SVFArrayType(u32_t id, bool svt, u32_t byteSize, unsigned elemNum) + : SVFType(svt, SVFArrayTy, id, byteSize), numOfElement(elemNum), typeOfElement(nullptr) + { + } static inline bool classof(const SVFType* node) @@ -457,6 +543,21 @@ class SVFArrayType : public SVFType return numOfElement; } + std::string toDBString() const + { + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFArrayType {id:" +std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", stinfo_node_id:" + std::to_string(getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + + ", num_of_element:" + std::to_string(getNumOfElement()) + + ", type_of_element_node_type_id:" + std::to_string(getTypeOfElement()->getId()) + "})"; + return queryStatement; + } + }; @@ -468,6 +569,7 @@ class SVFOtherType : public SVFType public: SVFOtherType(u32_t i, bool isSingleValueTy, u32_t byteSize = 1) : SVFType(isSingleValueTy, SVFOtherTy, i, byteSize) {} + SVFOtherType(u32_t i, bool isSingleValueTy, u32_t byteSize, std::string repr) : SVFType(isSingleValueTy, SVFOtherTy, i, byteSize),repr(repr) {} static inline bool classof(const SVFType* node) { @@ -494,6 +596,19 @@ class SVFOtherType : public SVFType } void print(std::ostream& os) const override; + + std::string toDBString() const + { + std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFOtherType {id:" + std::to_string(getId()) + + ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + + ", kind:" + std::to_string(getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(getByteSize()) + + ", repr:'" + getRepr() + "'})"; + return queryStatement; + } }; // TODO: be explicit that this is a pair of 32-bit unsigneds? @@ -623,4 +738,4 @@ template struct std::hash> } }; -#endif /* INCLUDE_SVFIR_SVFTYPE_H_ */ +#endif /* INCLUDE_SVFIR_SVFTYPE_H_ */ \ No newline at end of file diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index 1429377cc..f33104c6a 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -257,13 +257,32 @@ class SVFVar : public GenericPAGNodeTy */ class ValVar: public SVFVar { + friend class GraphDBClient; + friend class RetValPN; + friend class ConstDataValVar; + friend class ArgValVar; + friend class GepValVar; + friend class DummyValVar; + friend class FunValVar; + friend class GlobalValVar; + friend class ConstAggValVar; + friend class VarArgValPN; private: const ICFGNode* icfgNode; // icfgnode related to valvar - + ValVar(NodeID i, const SVFType* type, PNODEK ty = ValNode) : SVFVar(i, type, ty), icfgNode(nullptr) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ + inline void updateSVFValVar(const SVFType* type, const ICFGNode* icfgNode) + { + this->type = type; + this->icfgNode = icfgNode; + } + inline void updateSVFValVar(const ICFGNode* icfgNode) + { + this->icfgNode = icfgNode; + } static inline bool classof(const ValVar*) { return true; @@ -308,6 +327,9 @@ class ValVar: public SVFVar */ class ObjVar: public SVFVar { + friend class GraphDBClient; + friend class BaseObjVar; + friend class GepObjVar; protected: /// Constructor @@ -316,6 +338,10 @@ class ObjVar: public SVFVar { } public: + void updateObjVar(const SVFType* type) + { + this->type = type; + } /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ static inline bool classof(const ObjVar*) @@ -354,11 +380,17 @@ class ObjVar: public SVFVar */ class ArgValVar: public ValVar { + friend class GraphDBClient; private: const FunObjVar* cgNode; u32_t argNo; +protected: + /// Constructor to create function argument (for SVFIRReader/deserialization) + ArgValVar(NodeID i, PNODEK ty = ArgValNode) : ValVar(i, ty) {} + ArgValVar(NodeID i, const SVFType* type, u32_t argNo, PNODEK ty = ArgValNode) : ValVar(i, type, ty), argNo(argNo) {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -394,6 +426,11 @@ class ArgValVar: public ValVar return getName() + " (argument valvar)"; } + inline void addCGNode(const FunObjVar* cgNode) + { + this->cgNode = cgNode; + } + virtual const FunObjVar* getFunction() const; const FunObjVar* getParent() const; @@ -454,11 +491,20 @@ class GepValVar: public ValVar { return ap; } + + inline const void setAccessPath(const AccessPath* ap) + { + this->ap = *ap; + } //@} /// Constructor GepValVar(const ValVar* baseNode, NodeID i, const AccessPath& ap, const SVFType* ty, const ICFGNode* node); + GepValVar(NodeID i, const SVFType* type, const SVFType* gepValType, PNODEK ty = GepValNode) + : ValVar(i, type, GepValNode), gepValType(gepValType) + { + } /// offset of the base value variable inline APOffset getConstantFieldIdx() const @@ -471,6 +517,10 @@ class GepValVar: public ValVar { return base; } + inline void setBaseNode(const ValVar* baseNode) + { + base = baseNode; + } /// Return name of a LLVM value inline const std::string getValueName() const @@ -517,11 +567,25 @@ class GepValVar: public ValVar class BaseObjVar : public ObjVar { friend class SVFIRBuilder; + friend class ConstDataObjVar; + friend class DummyObjVar; + friend class ConstAggObjVar; + friend class GlobalObjVar; + friend class FunObjVar; + friend class GraphDBClient; + friend class StackObjVar; + friend class HeapObjVar; + private: ObjTypeInfo* typeInfo; const ICFGNode* icfgNode; /// ICFGNode related to the creation of this object +protected: + /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) + BaseObjVar(NodeID i, const ICFGNode* node, PNODEK ty = BaseObjNode) : ObjVar(i, ty), icfgNode(node) {} + BaseObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = BaseObjNode) : ObjVar(i, type, ty), typeInfo(typeInfo), icfgNode(nullptr) {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -563,6 +627,10 @@ class BaseObjVar : public ObjVar { return typeInfo; } + inline ObjTypeInfo* getTypeInfo() + { + return typeInfo; + } /// Get the ICFGNode related to the creation of this object inline const ICFGNode* getICFGNode() const @@ -570,6 +638,11 @@ class BaseObjVar : public ObjVar return icfgNode; } + inline void setICFGNode(const ICFGNode* node) + { + icfgNode = node; + } + /// Return name of a LLVM value inline const std::string getValueName() const { @@ -587,7 +660,7 @@ class BaseObjVar : public ObjVar /// Get obj type const SVFType* getType() const { - return typeInfo->getType(); + return type; } /// Get the number of elements of this object @@ -718,6 +791,11 @@ class BaseObjVar : public ObjVar */ class GepObjVar: public ObjVar { + friend class GraphDBClient; + +protected: + GepObjVar(NodeID i, const SVFType* type, u64_t apOffset, const BaseObjVar* baseObj, PNODEK ty = GepObjNode) + : ObjVar(i, type, ty), apOffset(apOffset), base(baseObj) {} private: APOffset apOffset = 0; @@ -822,6 +900,13 @@ class GepObjVar: public ObjVar class HeapObjVar: public BaseObjVar { + friend class GraphDBClient; + +protected: + /// Constructor to create heap object var + HeapObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, HeapObjNode) {} + HeapObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, PNODEK ty = HeapObjNode) : + BaseObjVar(i, type, ti, ty) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -878,6 +963,14 @@ class HeapObjVar: public BaseObjVar class StackObjVar: public BaseObjVar { + friend class GraphDBClient; + +protected: + /// Constructor to create stack object var + StackObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, StackObjNode) {} + StackObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, PNODEK ty = StackObjNode) : + BaseObjVar(i, type, ti, ty) {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -929,6 +1022,26 @@ class FunObjVar : public BaseObjVar { friend class SVFIRBuilder; friend class LLVMModuleSet; + friend class GraphDBClient; + +protected: + FunObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, + bool isDecl, bool intrinsic, bool isAddrTaken, bool isUncalled, + bool isNotRet, bool supVarArg, const SVFFunctionType* funcType, PNODEK ty = FunObjNode) + : BaseObjVar(i, type, ti, ty), isDecl(isDecl), intrinsic(intrinsic), + isAddrTaken(isAddrTaken), isUncalled(isUncalled), isNotRet(isNotRet), + supVarArg(supVarArg),funcType(funcType) {} + + inline void updateExitBlock(SVFBasicBlock *bb) + { + exitBlock = bb; + } + + inline void setLoopAndDomInfo(SVFLoopAndDomInfo *ld) + { + loopAndDom = ld; + } + public: typedef SVFLoopAndDomInfo::BBSet BBSet; @@ -1203,6 +1316,12 @@ class FunObjVar : public BaseObjVar class FunValVar : public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty FunValNode (for GraphDBClient) + FunValVar(NodeID i, const SVFType* type, PNODEK ty = FunValNode) : ValVar(i, type, ty) {} + private: const FunObjVar* funObjVar; @@ -1245,6 +1364,10 @@ class FunValVar : public ValVar return true; } + inline void setFunction(const FunObjVar* cgn) + { + funObjVar = cgn; + } virtual const std::string toString() const; }; @@ -1252,6 +1375,11 @@ class FunValVar : public ValVar class GlobalValVar : public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty GlobalValVar (for GraphDBClient) + GlobalValVar(NodeID i, const SVFType* type, PNODEK ty = GlobalValNode) : ValVar(i, type, ty) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1291,6 +1419,11 @@ class GlobalValVar : public ValVar class ConstAggValVar: public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty ConstAggValVar (for GraphDBClient) + ConstAggValVar(NodeID i, const SVFType* type, PNODEK ty = ConstAggValNode) : ValVar(i, type, ty) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1341,6 +1474,18 @@ class ConstAggValVar: public ValVar class ConstDataValVar : public ValVar { + friend class ConstNullPtrValVar; + friend class GraphDBClient; + friend class BlackHoleValVar; + friend class ConstFPValVar; + friend class ConstIntValVar; + +protected: + /// Constructor + ConstDataValVar(NodeID i, const SVFType* svfType, PNODEK ty = ConstDataValNode) + : ValVar(i, svfType, ty) + { + } public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1441,6 +1586,14 @@ class BlackHoleValVar : public ConstDataValVar class ConstFPValVar : public ConstDataValVar { + friend class GraphDBClient; + +protected: + /// Constructor + ConstFPValVar(NodeID i, double dv, const SVFType* svfType, PNODEK ty = ConstFPValNode) + : ConstDataValVar(i, svfType, ConstFPValNode), dval(dv) + { + } private: double dval; @@ -1491,6 +1644,16 @@ class ConstFPValVar : public ConstDataValVar class ConstIntValVar : public ConstDataValVar { + friend class GraphDBClient; + +protected: + /// Constructor + ConstIntValVar(NodeID i, s64_t sv, u64_t zv, const SVFType* svfType, PNODEK ty = ConstIntValNode) + : ConstDataValVar(i, svfType, ConstIntValNode), zval(zv), sval(sv) + { + + } + private: u64_t zval; s64_t sval; @@ -1546,6 +1709,13 @@ class ConstIntValVar : public ConstDataValVar class ConstNullPtrValVar : public ConstDataValVar { + friend class GraphDBClient; + +protected: + ConstNullPtrValVar(NodeID i, const SVFType* svfType, PNODEK ty = ConstNullptrValNode) + : ConstDataValVar(i, svfType, ty) + { + } public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1593,6 +1763,18 @@ class ConstNullPtrValVar : public ConstDataValVar class GlobalObjVar : public BaseObjVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty ObjVar (for GraphDBClient) + GlobalObjVar(NodeID i, const SVFType* svfType, ObjTypeInfo* ti, PNODEK ty = GlobalObjNode) + : BaseObjVar(i, svfType, ti, ty) + { + } + +private: + /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) + GlobalObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, GlobalObjNode) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1636,6 +1818,13 @@ class GlobalObjVar : public BaseObjVar class ConstAggObjVar : public BaseObjVar { + friend class GraphDBClient; + +protected: + ConstAggObjVar(NodeID i, const SVFType* svfType, ObjTypeInfo* ti, PNODEK ty = ConstAggObjNode) + : BaseObjVar(i, svfType, ti, ty) + { + } public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1689,6 +1878,18 @@ class ConstAggObjVar : public BaseObjVar class ConstDataObjVar : public BaseObjVar { + friend class ConstNullPtrObjVar; + friend class ConstIntObjVar; + friend class GraphDBClient; + friend class ConstFPObjVar; + +protected: + /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) + ConstDataObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, ConstDataObjNode) {} + ConstDataObjVar(NodeID i, const SVFType* svfType, ObjTypeInfo* typeInfo, PNODEK ty = ConstDataObjNode) + : BaseObjVar(i, svfType, typeInfo, ty) + { + } public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: @@ -1741,6 +1942,19 @@ class ConstDataObjVar : public BaseObjVar class ConstFPObjVar : public ConstDataObjVar { + friend class GraphDBClient; + +protected: + /// Constructor + ConstFPObjVar(NodeID i, float dval, const SVFType* svfType, ObjTypeInfo* ti, PNODEK ty = ConstFPObjNode) + : ConstDataObjVar(i, svfType, ti, ty), dval(dval) + { + } + +private: + /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) + ConstFPObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} + private: float dval; @@ -1798,6 +2012,18 @@ class ConstFPObjVar : public ConstDataObjVar class ConstIntObjVar : public ConstDataObjVar { + friend class GraphDBClient; + +protected: + ConstIntObjVar(NodeID i, s64_t sval, u64_t zval, const SVFType* svfType, ObjTypeInfo* objTypeInfo, PNODEK ty = ConstIntObjNode) + : ConstDataObjVar(i, svfType, objTypeInfo, ty), zval(zval), sval(sval) + { + } + +private: + /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) + ConstIntObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} + private: u64_t zval; s64_t sval; @@ -1862,6 +2088,15 @@ class ConstIntObjVar : public ConstDataObjVar class ConstNullPtrObjVar : public ConstDataObjVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty DummyObjVar (for GraphDBClient) + ConstNullPtrObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = ConstNullptrObjNode) : ConstDataObjVar(i, type, typeInfo, ty) {} +private: + /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) + ConstNullPtrObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} + public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const ConstNullPtrObjVar*) @@ -1914,6 +2149,11 @@ class ConstNullPtrObjVar : public ConstDataObjVar */ class RetValPN : public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty RetValPN (for GraphDBClient) + RetValPN(NodeID i, const SVFType* type, PNODEK ty = RetValNode) : ValVar(i, type, ty) {} private: const FunObjVar* callGraphNode; @@ -1951,6 +2191,11 @@ class RetValPN : public ValVar return callGraphNode; } + inline void setCallGraphNode(const FunObjVar* node) + { + callGraphNode = node; + } + virtual const FunObjVar* getFunction() const; virtual bool isPointer() const; @@ -1967,6 +2212,11 @@ class RetValPN : public ValVar class VarArgValPN : public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty VarArgValPN (for GraphDBClient) + VarArgValPN(NodeID i, const SVFType* type, PNODEK ty = VarargValNode) : ValVar(i, type, VarargValNode) {} private: const FunObjVar* callGraphNode; @@ -2002,6 +2252,11 @@ class VarArgValPN : public ValVar virtual const FunObjVar* getFunction() const; + inline void setCallGraphNode(const FunObjVar* node) + { + callGraphNode = node; + } + /// Return name of a LLVM value const std::string getValueName() const; @@ -2017,6 +2272,11 @@ class VarArgValPN : public ValVar */ class DummyValVar: public ValVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty DummyValVar (for GraphDBClient) + DummyValVar(NodeID i, const SVFType* type, PNODEK ty = DummyValNode) : ValVar(i, type, DummyValNode) {} public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: @@ -2068,6 +2328,16 @@ class DummyValVar: public ValVar class DummyObjVar: public BaseObjVar { + friend class GraphDBClient; + +protected: + /// Constructor to create empty DummyObjVar (for GraphDBClient) + DummyObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = DummyObjNode) : BaseObjVar(i, type, typeInfo, ty) {} + +private: + /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) + DummyObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, DummyObjNode) {} + public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const DummyObjVar*) diff --git a/svf/include/Util/NodeIDAllocator.h b/svf/include/Util/NodeIDAllocator.h index 27803385e..b52eff696 100644 --- a/svf/include/Util/NodeIDAllocator.h +++ b/svf/include/Util/NodeIDAllocator.h @@ -89,6 +89,17 @@ class NodeIDAllocator ++numNodes; } + inline void increaseNumOfValues() + { + ++numValues; + ++numNodes; + } + + inline int getNumOfNodes() + { + return numNodes; + } + private: /// Builds a node ID allocator with the strategy specified on the command line. NodeIDAllocator(void); diff --git a/svf/include/Util/SVFLoopAndDomInfo.h b/svf/include/Util/SVFLoopAndDomInfo.h index 70959be6f..8b3d99131 100644 --- a/svf/include/Util/SVFLoopAndDomInfo.h +++ b/svf/include/Util/SVFLoopAndDomInfo.h @@ -41,6 +41,9 @@ namespace SVF class SVFLoopAndDomInfo { + friend class GraphDBClient; + + public: typedef Set BBSet; typedef std::vector BBList; @@ -54,6 +57,37 @@ class SVFLoopAndDomInfo Map bb2LoopMap; ///< map a BasicBlock (if it is in a loop) to all the BasicBlocks in this loop Map bb2PdomLevel; ///< map a BasicBlock to its level in pdom tree, used in findNearestCommonPDominator Map bb2PIdom; ///< map a BasicBlock to its immediate dominator in pdom tree, used in findNearestCommonPDominator + +protected: +inline void setDomTreeMap(Map& dtMap) +{ + dtBBsMap = dtMap; +} + +inline void setPostDomTreeMap(Map& pdtMap) +{ + pdtBBsMap = pdtMap; +} + +inline void setDomFrontierMap(Map& dfMap) +{ + dfBBsMap = dfMap; +} + +inline void setBB2LoopMap(Map& bb2Loop) +{ + bb2LoopMap = bb2Loop; +} + +inline void setBB2PdomLevel(Map& bb2Pdom) +{ + bb2PdomLevel = bb2Pdom; +} + +inline void setBB2PIdom(Map& bb2PIdomMap) +{ + bb2PIdom = bb2PIdomMap; +} public: SVFLoopAndDomInfo() diff --git a/svf/lib/Graphs/CallGraph.cpp b/svf/lib/Graphs/CallGraph.cpp index 1038c849c..490ae41b3 100644 --- a/svf/lib/Graphs/CallGraph.cpp +++ b/svf/lib/Graphs/CallGraph.cpp @@ -32,6 +32,7 @@ #include "SVFIR/SVFIR.h" #include "Util/Options.h" #include "Util/SVFUtil.h" +#include "SVFIR/GraphDBClient.h" #include using namespace SVF; @@ -64,6 +65,40 @@ void CallGraphEdge::addInDirectCallSite(const CallICFGNode* call) } //@} +std::string CallGraphEdge::toDBString() const +{ + std::string indirectCallIds = ""; + Set indirectCall = getIndirectCalls(); + if (indirectCall.size() > 0) + { + indirectCallIds = GraphDBClient::getInstance().extractNodesIds(indirectCall); + } + + std::string directCallIds = ""; + Set directCall = getDirectCalls(); + if (directCall.size() > 0) + { + directCallIds = GraphDBClient::getInstance().extractNodesIds(directCall); + } + + const std::string queryStatement = + "MATCH (n:CallGraphNode{id:"+std::to_string(getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(getDstNode()->getId()) + "}) WHERE n.id = " + + std::to_string(getSrcNode()->getId()) + + " AND m.id = " + std::to_string(getDstNode()->getId()) + + " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(getCallSiteID()) + + ", kind:" + std::to_string(getEdgeKind()) + + ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + + indirectCallIds + "'}]->(m)"; + return queryStatement; +} + +std::string CallGraphNode::toDBString() const +{ + const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(getId()) + + ", fun_obj_var_id: " + std::to_string(getFunction()->getId()) + sourceLocToDBString() + "})"; + return queryStatement; +} + const std::string CallGraphEdge::toString() const { std::string str; @@ -185,6 +220,19 @@ CallGraphEdge* CallGraph::hasGraphEdge(CallGraphNode* src, return nullptr; } +CallGraphEdge* CallGraph::hasGraphEdge(CallGraphEdge* cgEdge) +{ + CallGraphEdge* outEdge = cgEdge->getSrcNode()->hasOutgoingEdge(cgEdge); + CallGraphEdge* inEdge = cgEdge->getDstNode()->hasIncomingEdge(cgEdge); + if (outEdge && inEdge) + { + assert(outEdge == inEdge && "edges not match"); + return outEdge; + } + else + return nullptr; +} + /*! * get PTACallGraph edge via nodes */ @@ -225,6 +273,14 @@ void CallGraph::addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* } } +void CallGraph::addIndirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge) +{ + if (!hasGraphEdge(cgEdge)) + { + addEdge(cgEdge); + } +} + /*! * Get all callsite invoking this callee */ @@ -364,6 +420,13 @@ void CallGraph::addCallGraphNode(const FunObjVar* fun) callGraphNodeNum++; } +void CallGraph::addCallGraphNodeFromDB(CallGraphNode* cgNode) +{ + addGNode(cgNode->getId(), cgNode); + funToCallGraphNodeMap[cgNode->getFunction()] = cgNode; + callGraphNodeNum++; +} + const CallGraphNode* CallGraph::getCallGraphNode(const std::string& name) const { for (const auto& item : *this) @@ -393,6 +456,14 @@ void CallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* c } } +void CallGraph::addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge) +{ + if (!hasGraphEdge(cgEdge)) + { + addEdge(cgEdge); + } +} + namespace SVF { @@ -475,4 +546,4 @@ struct DOTGraphTraits : public DefaultDOTGraphTraits return rawstr.str(); } }; -} // End namespace llvm +} // End namespace llvm \ No newline at end of file diff --git a/svf/lib/Graphs/IRGraph.cpp b/svf/lib/Graphs/IRGraph.cpp index 497ddfd7e..6c73ba1bb 100644 --- a/svf/lib/Graphs/IRGraph.cpp +++ b/svf/lib/Graphs/IRGraph.cpp @@ -304,6 +304,17 @@ SVFStmt* IRGraph::hasLabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind, return nullptr; } +SVFStmt* IRGraph::hasEdge(SVFStmt* edge, SVFStmt::PEDGEK kind) +{ + SVFStmt::SVFStmtSetTy::iterator it = KindToSVFStmtSetMap[kind].find(edge); + if (it != KindToSVFStmtSetMap[kind].end()) + { + return *it; + } + return nullptr; +} + + /*! * Dump this IRGraph */ diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 691f1cfc2..462f66700 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -3,6 +3,14 @@ using namespace SVF; +Map id2funObjVarsMap; +Set basicBlocks; +Map id2RetICFGNodeMap; +Map id2CallPEMap; +Map id2RetPEMap; +Map callCFGEdge2CallPEStrMap; +Map retCFGEdge2RetPEStrMap; + bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, const std::string& filepath, const std::string& dbname) @@ -12,13 +20,9 @@ bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, SVFUtil::outs() << "load schema from file:" << filepath << "\n"; std::string result; bool ret = connection->ImportSchemaFromFile(result, filepath, dbname); - if (ret) - { - SVFUtil::outs() << dbname<< "schema load successfully:" << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << dbname<< "schema load failed:" << result << "\n"; + SVFUtil::outs() << dbname<< "Warining: Schema load failed:" << result << "\n"; } return ret; } @@ -34,15 +38,10 @@ bool GraphDBClient::createSubGraph(lgraph::RpcClient* connection, const std::str std::string result; connection->CallCypher(result, "CALL dbms.graph.deleteGraph('"+graphname+"')"); bool ret = connection->CallCypherToLeader(result, "CALL dbms.graph.createGraph('"+graphname+"')"); - if (ret) - { - SVFUtil::outs() - << "Create Graph callGraph successfully:" << result << "\n"; - } - else + if (!ret) { SVFUtil::outs() - << "Failed to create Graph callGraph:" << result << "\n"; + << "Warining: Failed to create Graph callGraph:" << result << "\n"; } } return false; @@ -79,13 +78,9 @@ bool GraphDBClient::addICFGEdge2db(lgraph::RpcClient* connection, return false; } bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) + if (!ret) { - SVFUtil::outs() << "ICFG edge added: " << result << "\n"; - } - else - { - SVFUtil::outs() << "Failed to add ICFG edge to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add ICFG edge to db " << dbname << " " << result << "\n"; } return ret; @@ -138,13 +133,9 @@ bool GraphDBClient::addICFGNode2db(lgraph::RpcClient* connection, return false; } bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs()<< "ICFG node added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add icfg node to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add icfg node to db " << dbname << " " << result << "\n"; } return ret; @@ -158,20 +149,14 @@ bool GraphDBClient::addCallGraphNode2db(lgraph::RpcClient* connection, { if (nullptr != connection) { - std::string is_reachable_str = node->isReachableFromProgEntry() ? "true" : "false"; const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(node->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + - ", is_reachable_from_prog_entry: " + is_reachable_str + "})"; + ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) +"})"; // SVFUtil::outs()<<"CallGraph Node Insert Query:"<CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs()<< "CallGraph node added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add callGraph node to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add callGraph node to db " << dbname << " " << result << "\n"; } return ret; @@ -210,13 +195,9 @@ bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, // SVFUtil::outs() << "Call Graph Edge Insert Query:" << queryStatement << "\n"; std::string result; bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs() << "CallGraph edge added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add callgraph edge to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add callgraph edge to db " << dbname << " " << result << "\n"; } return ret; @@ -247,6 +228,7 @@ std::string GraphDBClient::getIntraICFGNodeInsertStmt(const IntraICFGNode* node) const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(node->getId()) + ", kind: " + std::to_string(node->getNodeKind()) + ", is_return: " + (node->isRetInst() ? "true" : "false") + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + ", bb_id:" + std::to_string(node->getBB()->getId()) + "})"; return queryStatement; } @@ -261,21 +243,23 @@ std::string GraphDBClient::getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(node->getId()) + ", kind: " + std::to_string(node->getNodeKind()) + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", bb_id:" + std::to_string(node->getBB()->getId()) + ", fp_nodes:'" + extractNodesIds(node->getFormalParms()) +"'})"; return queryStatement; } std::string GraphDBClient::getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node) { std::string formalRetId = ""; - if (node->getFormalRet() == nullptr) + if (nullptr == node->getFormalRet()) { - formalRetId = ""; + formalRetId = ",formal_ret_node_id:-1"; } else { formalRetId = ",formal_ret_node_id:" + std::to_string(node->getFormalRet()->getId()); } const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(node->getId()) + ", kind: " + std::to_string(node->getNodeKind()) + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", bb_id:" + std::to_string(node->getBB()->getId()) + formalRetId + "})"; return queryStatement; } @@ -283,7 +267,7 @@ std::string GraphDBClient::getFunExitICFGNodeInsertStmt(const FunExitICFGNode* n std::string GraphDBClient::getCallICFGNodeInsertStmt(const CallICFGNode* node) { std::string fun_name_of_v_call = ""; std::string vtab_ptr_node_id = ""; - std::string virtual_fun_idx = "0"; + std::string virtual_fun_idx = ""; std::string is_vir_call_inst = node->isVirtualCall() ? "true" : "false"; std::string virtualFunAppendix = ""; if (node->isVirtualCall()) @@ -293,17 +277,37 @@ std::string GraphDBClient::getCallICFGNodeInsertStmt(const CallICFGNode* node) { virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(node->getFunIdxInVtable()); virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; } + else + { + vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; + virtual_fun_idx = ", virtual_fun_idx:-1"; + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; + } std::string called_fun_obj_var_id = ""; if (node->getCalledFunction() != nullptr) { called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(node->getCalledFunction()->getId()); } + else + { + called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; + } + std::string ret_icfg_node_id = ""; + if (node->getRetICFGNode() != nullptr) + { + ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()); + } + else + { + ret_icfg_node_id = ", ret_icfg_node_id: -1"; + } const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(node->getId()) + ", kind: " + std::to_string(node->getNodeKind()) + - ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()) + + ret_icfg_node_id + ", bb_id: " + std::to_string(node->getBB()->getId()) + - ", svf_type:'" + node->getType()->toString() + - "', ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'"+ + ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + + ", svf_type:'" + node->getType()->toString() + "'" + + ", ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'" + called_fun_obj_var_id + ", is_vararg: " + (node->isVarArg() ? "true" : "false") + ", is_vir_call_inst: " + (node->isVirtualCall() ? "true" : "false") + @@ -316,11 +320,16 @@ std::string GraphDBClient::getRetICFGNodeInsertStmt(const RetICFGNode* node) { if (node->getActualRet() != nullptr) { actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(node->getActualRet()->getId()) ; + } else { + actual_ret_node_id = ", actual_ret_node_id: -1"; } const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(node->getId()) + ", kind: " + std::to_string(node->getNodeKind()) + actual_ret_node_id+ - ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + "})"; + ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + + ", bb_id: " + std::to_string(node->getBB()->getId()) + + ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + + ", svf_type:'" + node->getType()->toString() + "'"+"})"; return queryStatement; } @@ -369,6 +378,8 @@ std::string GraphDBClient::getIntraCFGEdgeStmt(const IntraCFGEdge* edge) { { condition = ", condition_var_id:"+ std::to_string(edge->getCondition()->getId()) + ", branch_cond_val:" + std::to_string(edge->getSuccessorCondValue()); + } else { + condition = ", condition_var_id:-1, branch_cond_val:-1"; } const std::string queryStatement = "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + @@ -400,6 +411,8 @@ std::string GraphDBClient::getRetCFGEdgeStmt(const RetCFGEdge* edge) { if (edge->getRetPE() != nullptr) { ret_pe_id = ", ret_pe_id:"+ std::to_string(edge->getRetPE()->getEdgeID()); + } else { + ret_pe_id = ", ret_pe_id:-1"; } const std::string queryStatement = "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + @@ -411,6 +424,110 @@ std::string GraphDBClient::getRetCFGEdgeStmt(const RetCFGEdge* edge) { return queryStatement; } +void GraphDBClient::insertCHG2db(const CHGraph* chg) +{ + std::string chgNodePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; + std::string chgEdgePath = + SVF_ROOT "/svf/include/Graphs/DBSchema/CHGEdgeSchema.json"; + // add all CHG Node & Edge to DB + if (nullptr != connection) + { + // create a new graph name CHG in db + createSubGraph(connection, "CHG"); + // load schema for CHG + loadSchema(connection, chgEdgePath.c_str(), "CHG"); + loadSchema(connection, chgNodePath.c_str(), "CHG"); + std::vector edges; + for (auto it = chg->begin(); it != chg->end(); ++it) + { + CHNode* node = it->second; + insertCHNode2db(connection, node, "CHG"); + for (auto edgeIter = node->OutEdgeBegin(); + edgeIter != node->OutEdgeEnd(); ++edgeIter) + { + CHEdge* edge = *edgeIter; + edges.push_back(edge); + } + } + for (const auto& edge : edges) + { + insertCHEdge2db(connection, edge, "CHG"); + } + } +} + +void GraphDBClient::insertCHNode2db(lgraph::RpcClient* connection, const CHNode* node, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement; + if (SVFUtil::isa(node)) + { + queryStatement = getCHNodeInsertStmt(SVFUtil::cast(node)); + } + else + { + assert("unknown CHG node type?"); + return ; + } + // SVFUtil::outs()<<"CHNode Insert Query:"<CallCypher(result, queryStatement, dbname); + if (!ret) + { + SVFUtil::outs() << "Warining: Failed to add CHG node to db " << dbname << " " + << result << "\n"; + } + } +} + +std::string GraphDBClient::getCHNodeInsertStmt(const CHNode* node) +{ + const std::string queryStatement ="CREATE (n:CHNode {class_name:'" + node->getName() + "'" + + ", vtable_id: " + std::to_string(node->getVTable()->getId()) + + ", flags:'" + std::to_string(node->getFlags()) +"'" + + ", virtual_function_vectors:'" + extractFuncVectors2String(node->getVirtualFunctionVectors()) + "'" + + + "})"; + return queryStatement; +} + +std::string GraphDBClient::getCHEdgeInsertStmt(const CHEdge* edge) +{ + const std::string queryStatement = + "MATCH (n:CHNode{class_name:'"+edge->getSrcNode()->getName()+"'}), (m:CHNode{class_name:'"+edge->getDstNode()->getName()+"'}) WHERE n.class_name = '" + + edge->getSrcNode()->getName() + + "' AND m.class_name = '" + edge->getDstNode()->getName() + + "' CREATE (n)-[r:CHEdge{edge_type:" + std::to_string(edge->getEdgeType()) + + "}]->(m)"; + return queryStatement; +} + +void GraphDBClient::insertCHEdge2db(lgraph::RpcClient* connection, const CHEdge* edge, const std::string& dbname) +{ + if (nullptr != connection) + { + std::string queryStatement; + if (SVFUtil::isa(edge)) + { + queryStatement = getCHEdgeInsertStmt(SVFUtil::cast(edge)); + } + else + { + assert("unknown CHG edge type?"); + return ; + } + // SVFUtil::outs()<<"CHEdge Insert Query:"<CallCypher(result, queryStatement, dbname); + if (!ret) + { + SVFUtil::outs() << "Warining: Failed to add CHG edge to db " << dbname << " " + << result << "\n"; + } + } +} + void GraphDBClient::insertICFG2db(const ICFG* icfg) { // add all ICFG Node & Edge to DB @@ -535,13 +652,9 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co // SVFUtil::outs()<<"SVFType Insert Query:"<CallCypher(result, queryStatement, dbname); - if (ret) + if (!ret) { - SVFUtil::outs()<< "SVFType node added: " << result << "\n"; - } - else - { - SVFUtil::outs() << "Failed to add SVFType node to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add SVFType node to db " << dbname << " " << result << "\n"; } @@ -555,13 +668,9 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co // SVFUtil::outs()<<"StInfo Insert Query:"<CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs()<< "StInfo node added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add StInfo node to db " << dbname << " " + SVFUtil::outs() << "Warining: Failed to add StInfo node to db " << dbname << " " << result << "\n"; } } @@ -572,7 +681,7 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co std::string GraphDBClient::getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFPointerTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFPointerType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -584,7 +693,7 @@ std::string GraphDBClient::getSVFPointerTypeNodeInsertStmt(const SVFPointerType* std::string GraphDBClient::getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFIntegerTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFIntegerType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -597,7 +706,7 @@ std::string GraphDBClient::getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* std::string GraphDBClient::getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFFunctionTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFFunctionType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -611,7 +720,7 @@ std::string GraphDBClient::getSVFFunctionTypeNodeInsertStmt(const SVFFunctionTyp std::string GraphDBClient::getSVFSturctTypeNodeInsertStmt(const SVFStructType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFStructTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFStructType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -625,7 +734,7 @@ std::string GraphDBClient::getSVFSturctTypeNodeInsertStmt(const SVFStructType* n std::string GraphDBClient::getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFArrayTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFArrayType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -640,7 +749,7 @@ std::string GraphDBClient::getSVFArrayTypeNodeInsertStmt(const SVFArrayType* nod std::string GraphDBClient::getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node) { std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFOtherTypeNode {type_name:'" + node->toString() + + const std::string queryStatement ="CREATE (n:SVFOtherType {type_name:'" + node->toString() + "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + "', kind:" + std::to_string(node->getKind()) + @@ -652,7 +761,7 @@ std::string GraphDBClient::getSVFOtherTypeNodeInsertStmt(const SVFOtherType* nod std::string GraphDBClient::getStInfoNodeInsertStmt(const StInfo* node) { - const std::string queryStatement ="CREATE (n:StInfoNode {id:" + std::to_string(node->getStinfoId()) + + const std::string queryStatement ="CREATE (n:StInfo {id:" + std::to_string(node->getStinfoId()) + ", fld_idx_vec:'" + extractIdxs(node->getFlattenedFieldIdxVec()) + "', elem_idx_vec:'" + extractIdxs(node->getFlattenedElemIdxVec()) + "', finfo_types:'" + extractSVFTypes(node->getFlattenFieldTypes()) + @@ -695,13 +804,9 @@ void GraphDBClient::insertBBEdge2db(lgraph::RpcClient* connection, const BasicBl if (!queryStatement.empty()) { bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs() << "BB edge added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add BB edge to db " << dbname + SVFUtil::outs() << "Warining: Failed to add BB edge to db " << dbname << " " << result << "\n"; } } @@ -718,13 +823,9 @@ void GraphDBClient::insertBBNode2db(lgraph::RpcClient* connection, const SVFBasi if (!queryStatement.empty()) { bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs() << "BB node added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add BB node to db " << dbname + SVFUtil::outs() << "Warining: Failed to add BB node to db " << dbname << " " << result << "\n"; } } @@ -735,6 +836,7 @@ std::string GraphDBClient::getBBNodeInsertStmt(const SVFBasicBlock* node) { const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(node->getId())+":" + std::to_string(node->getFunction()->getId()) + "'" + ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + + ", bb_name:'" + node->getName() +"'" + ", sscc_bb_ids:'" + extractNodesIds(node->getSuccBBs()) + "'" + ", pred_bb_ids:'" + extractNodesIds(node->getPredBBs()) + "'" + ", all_icfg_nodes_ids:'" + extractNodesIds(node->getICFGNodeList()) + "'" + @@ -814,13 +916,9 @@ void GraphDBClient::insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStm if (!queryStatement.empty()) { bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) + if (!ret) { - SVFUtil::outs() << "PAG edge added: " << result << "\n"; - } - else - { - SVFUtil::outs() << "Failed to add PAG edge to db " << dbname + SVFUtil::outs() << "Warining: Failed to add PAG edge to db " << dbname << " " << result << "\n"; } } @@ -919,13 +1017,9 @@ void GraphDBClient::insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar if (!queryStatement.empty()) { bool ret = connection->CallCypher(result, queryStatement, dbname); - if (ret) - { - SVFUtil::outs() << "PAG node added: " << result << "\n"; - } - else + if (!ret) { - SVFUtil::outs() << "Failed to add PAG node to db " << dbname + SVFUtil::outs() << "Warining: Failed to add PAG node to db " << dbname << " " << result << "\n"; } } @@ -1073,6 +1167,10 @@ std::string GraphDBClient::getValVarNodeFieldsStmt(const ValVar* node) { fieldsStr += ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); } + else + { + fieldsStr += ", icfg_node_id:-1"; + } return fieldsStr; } @@ -1252,6 +1350,10 @@ std::string GraphDBClient::getBaseObjVarNodeFieldsStmt(const BaseObjVar* node) { icfgIDstr = ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); } + else + { + icfgIDstr = ", icfg_node_id:-1"; + } std::string objTypeInfo_byteSize_str = ""; if (node->isConstantByteSize()) { @@ -1383,6 +1485,10 @@ std::string GraphDBClient::getFunObjVarNodeInsertStmt(const FunObjVar* node) if (node->hasBasicBlock() && nullptr != node->getExitBB()) { exitBBStr << ", exit_bb_id:" << std::to_string(node->getExitBB()->getId()); + } + else + { + exitBBStr << ", exit_bb_id:-1"; } const std::string queryStatement ="CREATE (n:FunObjVar {"+ getBaseObjVarNodeFieldsStmt(node) @@ -1416,10 +1522,18 @@ std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge) { valueStr += ", svf_var_node_id:"+ std::to_string(edge->getValue()->getId()); } + else + { + valueStr += ", svf_var_node_id:-1"; + } std::string bb_id_str = ""; if (nullptr != edge->getBB()) { - bb_id_str += ", bb_id:" + std::to_string(edge->getBB()->getId()); + bb_id_str += ", bb_id:'" + std::to_string(edge->getBB()->getParent()->getId()) + ":" + std::to_string(edge->getBB()->getId())+"'"; + } + else + { + bb_id_str += ", bb_id:''"; } std::string icfg_node_id_str = ""; @@ -1427,6 +1541,10 @@ std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge) { icfg_node_id_str += ", icfg_node_id:" + std::to_string(edge->getICFGNode()->getId()); } + else + { + icfg_node_id_str += ", icfg_node_id:-1"; + } std::string inst2_label_map = ""; if (nullptr != edge->getInst2LabelMap() && !edge->getInst2LabelMap()->empty()) @@ -1448,7 +1566,8 @@ std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge) var2_label_map + ", call_edge_label_counter:" + std::to_string(*(edge->getCallEdgeLabelCounter())) + ", store_edge_label_counter:" + std::to_string(*(edge->getStoreEdgeLabelCounter())) + - ", multi_opnd_label_counter:" + std::to_string(*(edge->getMultiOpndLabelCounter())); + ", multi_opnd_label_counter:" + std::to_string(*(edge->getMultiOpndLabelCounter())) + + ", edge_flag:" + std::to_string(edge->getEdgeKindWithoutMask()); return fieldsStr; } @@ -1560,6 +1679,10 @@ std::string GraphDBClient::generateGepStmtEdgeInsertStmt(const GepStmt* edge) accessPathStr << ", ap_fld_idx:" << std::to_string(edge->getConstantStructFldIdx()); } + else + { + accessPathStr << ", ap_fld_idx:-1"; + } if (nullptr != edge->getAccessPath().gepSrcPointeeType()) { @@ -1595,11 +1718,19 @@ std::string GraphDBClient::generateCallPEEdgeInsertStmt(const CallPE* edge) { callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } if (nullptr != edge->getFunEntryICFGNode()) { funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); const std::string queryStatement = @@ -1623,11 +1754,19 @@ std::string GraphDBClient::generateRetPEEdgeInsertStmt(const RetPE* edge) { callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } if (nullptr != edge->getFunExitICFGNode()) { funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); const std::string queryStatement = @@ -1651,11 +1790,19 @@ std::string GraphDBClient::generateTDForkPEEdgeInsertStmt(const TDForkPE* edge) { callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } if (nullptr != edge->getFunEntryICFGNode()) { funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); const std::string queryStatement = @@ -1679,11 +1826,19 @@ std::string GraphDBClient::generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge) { callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } if (nullptr != edge->getFunExitICFGNode()) { funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); const std::string queryStatement = @@ -1706,6 +1861,10 @@ std::string GraphDBClient::generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndSt { stmt += ", op_var_node_ids:'" + extractNodesIds(edge->getOpndVars())+"'"; } + else + { + stmt += ", op_var_node_ids:''"; + } return stmt; } @@ -1944,3 +2103,2740 @@ std::string GraphDBClient::getPAGNodeKindString(const SVFVar* node) return "SVFVar"; } + +void GraphDBClient::readSVFTypesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Build SVF types from DB....\n"; + addSVFTypeNodeFromDB(connection, dbname, pag); +} + +void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + // parse all SVFType + std::string queryStatement = "MATCH (node) WHERE NOT 'StInfo' IN labels(node) return node"; + + Map svfTypeMap; + Map stInfoMap; + // Map> svfTypeKind2SVFTypesMap; + Map> svfi8AndPtrTypeMap; + Map> functionRetTypeSetMap; + Map> functionParamsTypeSetMap; + Map> stInfoId2SVFTypeMap; + Map> elementTyepsMap; + + cJSON* root = queryFromDB(connection, dbname, queryStatement); + cJSON* node; + if (nullptr != root) + { + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + + std::string label = cJSON_GetObjectItem(data, "label")->valuestring; + + SVFType* type = nullptr; + std::string i8Type = + cJSON_GetObjectItem(properties, "svf_i8_type_name") + ->valuestring; + std::string ptrType = + cJSON_GetObjectItem(properties, "svf_ptr_type_name") + ->valuestring; + bool svt = cJSON_IsTrue( + cJSON_GetObjectItem(properties, "is_single_val_ty")); + int byteSize = + cJSON_GetObjectItem(properties, "byte_size")->valueint; + std::string typeNameString = + cJSON_GetObjectItem(properties, "type_name")->valuestring; + + if (label == "SVFPointerType") + { + type = new SVFPointerType(byteSize, svt); + } + else if (label == "SVFIntegerType") + { + cJSON* single_and_width_Json = + cJSON_GetObjectItem(properties, "single_and_width"); + short single_and_width = + (short)cJSON_GetNumberValue(single_and_width_Json); + type = new SVFIntegerType(byteSize, svt, single_and_width); + } + else if (label == "SVFFunctionType") + { + SVFFunctionType* funType = new SVFFunctionType(svt, byteSize); + type = funType; + std::string retTypeName = + cJSON_GetObjectItem(properties, "ret_ty_node_name") + ->valuestring; + auto it = svfTypeMap.find(retTypeName); + if (it != svfTypeMap.end()) + { + funType->setReturnType(it->second); + } + else + { + functionRetTypeSetMap[retTypeName].insert(funType); + } + std::string paramsTypes = + cJSON_GetObjectItem(properties, "params_types_vec") + ->valuestring; + if (!paramsTypes.empty()) + { + functionParamsTypeSetMap[funType] = + parseSVFTypes(paramsTypes); + } + } + else if (label == "SVFOtherType") + { + std::string repr = + cJSON_GetObjectItem(properties, "repr")->valuestring; + type = new SVFOtherType(svt, byteSize, repr); + } + else if (label == "SVFStructType") + { + std::string name = + cJSON_GetObjectItem(properties, "struct_name")->valuestring; + type = new SVFStructType(svt, byteSize, name); + int stInfoID = + cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; + auto it = stInfoMap.find(stInfoID); + if (it != stInfoMap.end()) + { + type->setTypeInfo(it->second); + } + else + { + stInfoId2SVFTypeMap[stInfoID].insert(type); + } + } + else if (label == "SVFArrayType") + { + int numOfElement = + cJSON_GetObjectItem(properties, "num_of_element")->valueint; + SVFArrayType* arrayType = + new SVFArrayType(svt, byteSize, numOfElement); + type = arrayType; + int stInfoID = + cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; + auto stInfoIter = stInfoMap.find(stInfoID); + if (stInfoIter != stInfoMap.end()) + { + type->setTypeInfo(stInfoIter->second); + } + else + { + stInfoId2SVFTypeMap[stInfoID].insert(type); + } + std::string typeOfElementName = + cJSON_GetObjectItem(properties, + "type_of_element_node_type_name") + ->valuestring; + auto tyepIter = svfTypeMap.find(typeOfElementName); + if (tyepIter != svfTypeMap.end()) + { + arrayType->setTypeOfElement(tyepIter->second); + } + else + { + elementTyepsMap[typeOfElementName].insert(arrayType); + } + } + svfTypeMap.emplace(typeNameString, type); + // svfTypeKind2SVFTypesMap[type->getSVFTyKind()].insert(type); + svfi8AndPtrTypeMap[type] = std::make_pair(i8Type, ptrType); + } + cJSON_Delete(root); + } + + // parse all StInfo + queryStatement = "MATCH (node:StInfo) return node"; + root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + + u32_t id = static_cast( + cJSON_GetObjectItem(properties, "id")->valueint); + std::string fld_idx_vec = + cJSON_GetObjectItem(properties, "fld_idx_vec")->valuestring; + std::vector fldIdxVec = + parseElements2Container>(fld_idx_vec); + + std::string elem_idx_vec = + cJSON_GetObjectItem(properties, "elem_idx_vec")->valuestring; + std::vector elemIdxVec = + parseElements2Container>(elem_idx_vec); + + std::string fld_idx_2_type_map = + cJSON_GetObjectItem(properties, "fld_idx_2_type_map") + ->valuestring; + Map fldIdx2TypeMap = + parseStringToFldIdx2TypeMap>( + fld_idx_2_type_map, svfTypeMap); + + std::string finfo_types = + cJSON_GetObjectItem(properties, "finfo_types")->valuestring; + std::vector finfo = + parseElementsToSVFTypeContainer>( + finfo_types, svfTypeMap); + + u32_t stride = static_cast( + cJSON_GetObjectItem(properties, "stride")->valueint); + u32_t num_of_flatten_elements = static_cast( + cJSON_GetObjectItem(properties, "num_of_flatten_elements") + ->valueint); + u32_t num_of_flatten_fields = static_cast( + cJSON_GetObjectItem(properties, "num_of_flatten_fields") + ->valueint); + std::string flatten_element_types = + cJSON_GetObjectItem(properties, "flatten_element_types") + ->valuestring; + std::vector flattenElementTypes = + parseElementsToSVFTypeContainer>( + flatten_element_types, svfTypeMap); + StInfo* stInfo = + new StInfo(id, fldIdxVec, elemIdxVec, fldIdx2TypeMap, finfo, + stride, num_of_flatten_elements, + num_of_flatten_fields, flattenElementTypes); + stInfoMap[id] = stInfo; + } + cJSON_Delete(root); + } + + for (auto& [retTypeName, types]:functionRetTypeSetMap) + { + auto retTypeIter = svfTypeMap.find(retTypeName); + if (retTypeIter != svfTypeMap.end()) + { + for (auto& type: types) + { + type->setReturnType(retTypeIter->second); + } + } + else + { + SVFUtil::outs() + << "Warning3: No matching SVFType found for type: " << retTypeName << "\n"; + } + } + Set ori = pag->getSVFTypes(); + + for (auto& [funType, paramsVec]:functionParamsTypeSetMap) + { + for (const std::string& param : paramsVec) + { + auto paramTypeIter = svfTypeMap.find(param); + if (paramTypeIter != svfTypeMap.end()) + { + funType->addParamType(paramTypeIter->second); + } + else + { + SVFUtil::outs()<<"Warning2: No matching SVFType found for type: " + << param << "\n"; + } + } + } + + for (auto&[stInfoId, types] : stInfoId2SVFTypeMap) + { + auto stInfoIter = stInfoMap.find(stInfoId); + if (stInfoIter != stInfoMap.end()) + { + for (SVFType* type: types) + { + type->setTypeInfo(stInfoIter->second); + if (stInfoIter->second->getNumOfFlattenFields() > pag->maxStSize) + { + pag->maxStSize = stInfoIter->second->getNumOfFlattenFields(); + pag->maxStruct = type; + } + } + } + else + { + SVFUtil::outs()<<"Warning: No matching StInfo found for id: " + << stInfoId << "\n"; + } + } + + for (auto& [elementTypesName, arrayTypes]:elementTyepsMap) + { + auto elementTypeIter = svfTypeMap.find(elementTypesName); + if (elementTypeIter != svfTypeMap.end()) + { + for (SVFArrayType* type : arrayTypes) + { + type->setTypeOfElement(elementTypeIter->second); + } + } + else + { + SVFUtil::outs()<<"Warning1: No matching SVFType found for type: " + << elementTypesName << "\n"; + } + } + + for (auto& [svfType, pair]:svfi8AndPtrTypeMap) + { + std::string svfi8Type = pair.first; + std::string svfptrType = pair.second; + auto i8Type = svfTypeMap.find(svfi8Type); + auto ptrType = svfTypeMap.find(svfptrType); + if (i8Type!=svfTypeMap.end()) + { + svfType->setSVFInt8Type(i8Type->second); + } + if (ptrType!= svfTypeMap.end()) + { + svfType->setSVFPtrType(ptrType->second); + } + } + for (auto& [typeName, type] : svfTypeMap) + { + pag->addTypeInfo(type); + } + for (auto& [id, stInfo]: stInfoMap) + { + pag->addStInfo(stInfo); + } +} + +void GraphDBClient::updateRetPE4RetCFGEdge() +{ + if (retCFGEdge2RetPEStrMap.size() > 0) + { + for (auto& [edge, id] : retCFGEdge2RetPEStrMap) + { + if (nullptr != edge && id != -1) + { + auto it = id2RetPEMap.find(id); + if (it != id2RetPEMap.end()) + { + RetPE* retPE = it->second; + edge->addRetPE(retPE); + } + else + { + SVFUtil::outs() << "Warning[updateRetPE4RetCFGEdge]: No matching RetPE found for id: " << id << "\n"; + } + } + } + } +} + +void GraphDBClient::updateCallPEs4CallCFGEdge() +{ + if (callCFGEdge2CallPEStrMap.size() > 0) + { + for (auto& [edge, ids] : callCFGEdge2CallPEStrMap) + { + if (nullptr != edge && !ids.empty()) + { + std::vector idVec = parseElements2Container>(ids); + for (int id : idVec) + { + auto it = id2CallPEMap.find(id); + if (it != id2CallPEMap.end()) + { + CallPE* callPE = it->second; + edge->addCallPE(callPE); + } + else + { + SVFUtil::outs() << "Warning[updateCallPEs4CallCFGEdge]: No matching CallPE found for id: " << id << "\n"; + } + } + } + } + } +} + +void GraphDBClient::loadSVFPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Loading SVF PAG edges from DB....\n"; + readPAGEdgesFromDB(connection, dbname, "AddrStmt", pag); + readPAGEdgesFromDB(connection, dbname, "CopyStmt", pag); + readPAGEdgesFromDB(connection, dbname, "StoreStmt", pag); + readPAGEdgesFromDB(connection, dbname, "LoadStmt", pag); + readPAGEdgesFromDB(connection, dbname, "GepStmt", pag); + readPAGEdgesFromDB(connection, dbname, "CallPE", pag); + readPAGEdgesFromDB(connection, dbname, "RetPE", pag); + readPAGEdgesFromDB(connection, dbname, "PhiStmt", pag); + readPAGEdgesFromDB(connection, dbname, "SelectStmt", pag); + readPAGEdgesFromDB(connection, dbname, "CmpStmt", pag); + readPAGEdgesFromDB(connection, dbname, "BinaryOPStmt", pag); + readPAGEdgesFromDB(connection, dbname, "UnaryOPStmt", pag); + readPAGEdgesFromDB(connection, dbname, "BranchStmt", pag); + readPAGEdgesFromDB(connection, dbname, "TDForkPE", pag); + readPAGEdgesFromDB(connection, dbname, "RetPETDJoinPE", pag); + + updateCallPEs4CallCFGEdge(); + updateRetPE4RetCFGEdge(); + SVFUtil::outs()<< "Loading SVF PAG edges from DB done....\n"; + +} + +void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag) +{ + int skip = 0; + int limit = 1000; + while (true) + { + // SVFUtil::outs() << "Loading SVF PAG edges from DB, edge type: " << edgeType << ", skip: " << skip << ", limit: " << limit << "\n"; + std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if ( nullptr == root) + { + break; + } + else + { + cJSON* edge; + cJSON_ArrayForEach(edge, root) + { + cJSON* data = cJSON_GetObjectItem(edge, "edge"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + + // parse src SVFVar & dst SVFVar + int src_id = cJSON_GetObjectItem(data,"src")->valueint; + int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; + SVFVar* srcNode = pag->getGNode(src_id); + SVFVar* dstNode = pag->getGNode(dst_id); + if (nullptr == srcNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching src SVFVar found for id: " << src_id << "\n"; + continue; + } + if( nullptr == dstNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching dst SVFVar found for id: " << dst_id << "\n"; + continue; + } + + int edge_id = cJSON_GetObjectItem(properties,"edge_id")->valueint; + int svf_var_node_id = cJSON_GetObjectItem(properties,"svf_var_node_id")->valueint; + SVFVar* value = nullptr; + if (svf_var_node_id != -1) + { + value = pag->getGNode(svf_var_node_id); + } + int icfg_node_id = cJSON_GetObjectItem(properties,"icfg_node_id")->valueint; + ICFGNode* icfgNode = nullptr; + if (icfg_node_id != -1) + { + icfgNode = pag->getICFG()->getICFGNode(icfg_node_id); + } + + std::string bb_id = cJSON_GetObjectItem(properties,"bb_id")->valuestring; + SVFBasicBlock* bb = nullptr; + if (!bb_id.empty()) + { + std::pair pair = parseBBIdPair(bb_id); + if (pair.first != -1 && pair.second != -1) + { + FunObjVar* fun = SVFUtil::dyn_cast(pag->getGNode(pair.first)); + if (nullptr != fun) + { + bb = fun->getBasicBlockGraph()->getGNode(pair.second); + if (nullptr == bb) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching BB found for id: " << bb_id << "\n"; + continue; + } + } + } + } + + int call_edge_label_counter = cJSON_GetObjectItem(properties,"call_edge_label_counter")->valueint; + int store_edge_label_counter = cJSON_GetObjectItem(properties,"store_edge_label_counter")->valueint; + int multi_opnd_label_counter = cJSON_GetObjectItem(properties,"multi_opnd_label_counter")->valueint; + s64_t edgeFlag = static_cast(cJSON_GetObjectItem(properties,"edge_flag")->valueint); + + SVFStmt* stmt = nullptr; + + if (edgeType == "AddrStmt") + { + stmt = new AddrStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); + std::string arr_size = cJSON_GetObjectItem(properties,"arr_size")->valuestring; + AddrStmt* addrStmt = SVFUtil::cast(stmt); + if (!arr_size.empty()) + { + Set arrSizeVec = parseElements2Container>(arr_size); + for (int varId : arrSizeVec) + { + SVFVar* var = pag->getGNode(varId); + if (nullptr != var) + { + addrStmt->addArrSize(var); + } + else + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFVar found for id: " << varId << " when processing AddrStmt:"<addAddrStmt(addrStmt); + } + else if (edgeType == "CopyStmt") + { + int copy_kind = cJSON_GetObjectItem(properties,"copy_kind")->valueint; + stmt = new CopyStmt(srcNode, dstNode, edgeFlag, edge_id, value, copy_kind, icfgNode ); + CopyStmt* copyStmt = SVFUtil::cast(stmt); + pag->addCopyStmt(copyStmt); + } + else if (edgeType == "StoreStmt") + { + stmt = new StoreStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); + StoreStmt* storeStmt = SVFUtil::cast(stmt); + pag->addStoreStmt(storeStmt, srcNode, dstNode); + } + else if (edgeType == "LoadStmt") + { + stmt = new LoadStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); + LoadStmt* loadStmt = SVFUtil::cast(stmt); + pag->addLoadStmt(loadStmt); + } + else if (edgeType == "GepStmt") + { + s64_t fldIdx = cJSON_GetObjectItem(properties, "ap_fld_idx")->valueint; + if (fldIdx == -1) + { + fldIdx = 0; + } + bool variant_field = cJSON_IsTrue(cJSON_GetObjectItem(properties,"variant_field")); + cJSON* ap_gep_pointee_type_name_node = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_name"); + const SVFType* gepPointeeType = nullptr; + std::string ap_gep_pointee_type_name = ""; + if (nullptr != ap_gep_pointee_type_name_node && nullptr != ap_gep_pointee_type_name_node->valuestring) + { + ap_gep_pointee_type_name = ap_gep_pointee_type_name_node->valuestring; + if (!ap_gep_pointee_type_name.empty()) + { + gepPointeeType = pag->getSVFType(ap_gep_pointee_type_name); + } + } + AccessPath* ap = nullptr; + if (nullptr != gepPointeeType) + { + ap = new AccessPath(fldIdx, gepPointeeType); + } + else + { + ap = new AccessPath(fldIdx); + if (!ap_gep_pointee_type_name.empty()) + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFType found for ap_gep_pointee_type_name: " << ap_gep_pointee_type_name << " when updating GepStmt:"<valuestring) + { + ap_idx_operand_pairs = ap_idx_operand_pairs_node->valuestring; + } + parseAPIdxOperandPairsString(ap_idx_operand_pairs, pag, ap); + + stmt = new GepStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, *ap, variant_field); + GepStmt* gepStmt = SVFUtil::cast(stmt); + pag->addGepStmt(gepStmt); + } + else if (edgeType == "CallPE") + { + int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; + int fun_entry_icfg_node_id = cJSON_GetObjectItem(properties,"fun_entry_icfg_node_id")->valueint; + const CallICFGNode* callICFGNode = nullptr; + const FunEntryICFGNode* funEntryICFGNode = nullptr; + if (call_icfg_node_id != -1) + { + callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); + if (nullptr == callICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; + continue; + } + } + if (fun_entry_icfg_node_id != -1) + { + funEntryICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_entry_icfg_node_id)); + if (nullptr == funEntryICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunEntryICFGNode found for id: " << fun_entry_icfg_node_id << "\n"; + continue; + } + } + stmt = new CallPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); + CallPE* callPE = SVFUtil::cast(stmt); + pag->addCallPE(callPE, srcNode, dstNode); + id2CallPEMap[edge_id] = callPE; + } + else if (edgeType == "TDForkPE") + { + int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; + int fun_entry_icfg_node_id = cJSON_GetObjectItem(properties,"fun_entry_icfg_node_id")->valueint; + const CallICFGNode* callICFGNode = nullptr; + const FunEntryICFGNode* funEntryICFGNode = nullptr; + if (call_icfg_node_id != -1) + { + callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); + if (nullptr == callICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; + continue; + } + } + if (fun_entry_icfg_node_id != -1) + { + funEntryICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_entry_icfg_node_id)); + if (nullptr == funEntryICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunEntryICFGNode found for id: " << fun_entry_icfg_node_id << "\n"; + continue; + } + } + stmt = new TDForkPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); + TDForkPE* forkPE = SVFUtil::cast(stmt); + pag->addCallPE(forkPE, srcNode, dstNode); + id2CallPEMap[edge_id] = forkPE; + } + else if (edgeType == "RetPE") + { + int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; + int fun_exit_icfg_node_id = cJSON_GetObjectItem(properties,"fun_exit_icfg_node_id")->valueint; + const CallICFGNode* callICFGNode = nullptr; + const FunExitICFGNode* funExitICFGNode = nullptr; + if (call_icfg_node_id != -1) + { + callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); + if (nullptr == callICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; + continue; + } + } + if (fun_exit_icfg_node_id != -1) + { + funExitICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_exit_icfg_node_id)); + if (nullptr == funExitICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunExitICFGNode found for id: " << fun_exit_icfg_node_id << "\n"; + continue; + } + } + stmt = new RetPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode,callICFGNode, funExitICFGNode); + RetPE* retPE = SVFUtil::cast(stmt); + pag->addRetPE(retPE, srcNode, dstNode); + id2RetPEMap[edge_id] = retPE; + } + else if (edgeType == "RetPETDJoinPE") + { + int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; + int fun_exit_icfg_node_id = cJSON_GetObjectItem(properties,"fun_exit_icfg_node_id")->valueint; + const CallICFGNode* callICFGNode = nullptr; + const FunExitICFGNode* funExitICFGNode = nullptr; + if (call_icfg_node_id != -1) + { + callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); + if (nullptr == callICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; + continue; + } + } + if (fun_exit_icfg_node_id != -1) + { + funExitICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_exit_icfg_node_id)); + if (nullptr == funExitICFGNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunExitICFGNode found for id: " << fun_exit_icfg_node_id << "\n"; + continue; + } + } + stmt = new TDJoinPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funExitICFGNode); + TDJoinPE* joinPE = SVFUtil::cast(stmt); + pag->addRetPE(joinPE, srcNode, dstNode); + id2RetPEMap[edge_id] = joinPE; + } + else if (edgeType == "PhiStmt") + { + std::vector opVarNodes; + std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; + parseOpVarString(op_var_node_ids, pag, opVarNodes); + stmt = new PhiStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, opVarNodes); + PhiStmt* phiStmt = SVFUtil::cast(stmt); + std::string op_icfg_nodes_ids = cJSON_GetObjectItem(properties, "op_icfg_nodes_ids")->valuestring; + if (!op_icfg_nodes_ids.empty()) + { + std::vector opICFGNodeIds = parseElements2Container>(op_icfg_nodes_ids); + std::vector opICFGNodes; + for (int icfgNodeId : opICFGNodeIds) + { + ICFGNode* opICFGNode = pag->getICFG()->getGNode(icfgNodeId); + if (nullptr != opICFGNode) + { + opICFGNodes.push_back(opICFGNode); + } + else + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << icfgNodeId << "\n"; + } + } + phiStmt->setOpICFGNodeVec(opICFGNodes); + } + pag->addPhiStmt(phiStmt, srcNode, dstNode); + } + else if (edgeType == "SelectStmt") + { + std::vector opVarNodes; + std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; + parseOpVarString(op_var_node_ids, pag, opVarNodes); + int condition_svf_var_node_id = cJSON_GetObjectItem(properties, "condition_svf_var_node_id")->valueint; + SVFVar* condition = pag->getGNode(condition_svf_var_node_id); + stmt = new SelectStmt(srcNode, dstNode, edgeFlag, edge_id, condition, value, icfgNode, opVarNodes); + SelectStmt* selectStmt = SVFUtil::cast(stmt); + pag->addSelectStmt(selectStmt, srcNode, dstNode); + } + else if (edgeType == "CmpStmt") + { + std::vector opVarNodes; + std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; + parseOpVarString(op_var_node_ids, pag, opVarNodes); + u32_t predicate = cJSON_GetObjectItem(properties, "predicate")->valueint; + stmt = new CmpStmt(srcNode, dstNode, edgeFlag, edge_id, value, predicate, icfgNode, opVarNodes); + CmpStmt* cmpStmt = SVFUtil::cast(stmt); + pag->addCmpStmt(cmpStmt, srcNode, dstNode); + } + else if (edgeType == "BinaryOPStmt") + { + std::vector opVarNodes; + std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; + parseOpVarString(op_var_node_ids, pag, opVarNodes); + u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; + stmt = new BinaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode, opVarNodes); + BinaryOPStmt* binaryOpStmt = SVFUtil::cast(stmt); + pag->addBinaryOPStmt(binaryOpStmt, srcNode, dstNode); + } + else if (edgeType == "UnaryOPStmt") + { + u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; + stmt = new UnaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode); + UnaryOPStmt* unaryOpStmt = SVFUtil::cast(stmt); + pag->addUnaryOPStmt(unaryOpStmt, srcNode, dstNode); + } + else if (edgeType == "BranchStmt") + { + int condition_svf_var_node_id = cJSON_GetObjectItem(properties, "condition_svf_var_node_id")->valueint; + int br_inst_svf_var_node_id = cJSON_GetObjectItem(properties, "br_inst_svf_var_node_id")->valueint; + const SVFVar* condition = pag->getGNode(condition_svf_var_node_id); + const SVFVar* brInst = pag->getGNode(br_inst_svf_var_node_id); + if (condition == nullptr) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching condition SVFVar found for id: " << condition_svf_var_node_id << "\n"; + continue; + } + if (brInst == nullptr) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching brInst SVFVar found for id: " << br_inst_svf_var_node_id << "\n"; + continue; + } + std::string successorsStr = cJSON_GetObjectItem(properties, "successors")->valuestring; + std::vector> successorsIdVec = parseSuccessorsPairSetFromString(successorsStr); + std::vector> successors; + for (auto& pair : successorsIdVec) + { + const ICFGNode* succ = pag->getICFG()->getGNode(pair.first); + if (nullptr != succ) + { + successors.push_back(std::make_pair(succ, pair.second)); + } + else + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << pair.first << "\n"; + } + } + stmt = new BranchStmt(srcNode, dstNode, edgeFlag, edge_id, value, successors, condition, brInst, icfgNode); + BranchStmt* branchStmt = SVFUtil::cast(stmt); + pag->addBranchStmt(branchStmt, srcNode, dstNode); + } + stmt->setBasicBlock(bb); + stmt->setCallEdgeLabelCounter(static_cast(call_edge_label_counter)); + stmt->setStoreEdgeLabelCounter(static_cast(store_edge_label_counter)); + stmt->setMultiOpndLabelCounter(static_cast(multi_opnd_label_counter)); + std::string inst2_label_map = cJSON_GetObjectItem(properties,"inst2_label_map")->valuestring; + std::string var2_label_map = cJSON_GetObjectItem(properties,"var2_label_map")->valuestring; + Map inst2_label_map_ids = parseLabelMapFromString>(inst2_label_map); + Map var2_label_map_ids = parseLabelMapFromString>(var2_label_map); + if (!inst2_label_map_ids.empty()) + { + for (auto& [id, label] : inst2_label_map_ids) + { + const ICFGNode* icfgNode = nullptr; + if (id != -1) + { + icfgNode = pag->getICFG()->getGNode(id); + if (nullptr == icfgNode) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << id << " when parsing inst2_label_map_ids\n"; + } + } + stmt->addInst2Labeled(icfgNode, label); + } + } + if (!var2_label_map_ids.empty()) + { + for (auto& [id, label] : var2_label_map_ids) + { + const SVFVar* var = nullptr; + if (id != -1) + { + var = pag->getGNode(id); + if (nullptr == var) + { + SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFVar found for id: " << id << " when parsing var2_label_map_ids\n"; + } + } + stmt->addVar2Labeled(var, label); + } + } + skip += 1; + } + cJSON_Delete(root); + } + } +} + +void GraphDBClient::parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes) +{ + if (!op_var_node_ids.empty()) + { + std::vector opVarNodeIds = parseElements2Container>(op_var_node_ids); + for (int varId : opVarNodeIds) + { + SVFVar* var = pag->getGNode(varId); + if (nullptr != var) + { + opVarNodes.push_back(var); + } + else + { + SVFUtil::outs() << "Warning: [parseOpVarString] No matching SVFVar found for id: " << varId << "\n"; + } + } + } +} + +void GraphDBClient::initialSVFPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Initial SVF PAG nodes from DB....\n"; + readPAGNodesFromDB(connection, dbname, "ValVar", pag); + readPAGNodesFromDB(connection, dbname, "ObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ArgValVar", pag); + readPAGNodesFromDB(connection, dbname, "GepValVar", pag); + readPAGNodesFromDB(connection, dbname, "BaseObjVar", pag); + readPAGNodesFromDB(connection, dbname, "GepObjVar", pag); + readPAGNodesFromDB(connection, dbname, "HeapObjVar", pag); + readPAGNodesFromDB(connection, dbname, "StackObjVar", pag); + readPAGNodesFromDB(connection, dbname, "FunObjVar", pag); + readPAGNodesFromDB(connection, dbname, "FunValVar", pag); + readPAGNodesFromDB(connection, dbname, "GlobalValVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstAggValVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstDataValVar", pag); + readPAGNodesFromDB(connection, dbname, "BlackHoleValVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstFPValVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstIntValVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstNullPtrValVar", pag); + readPAGNodesFromDB(connection, dbname, "GlobalObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstAggObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstDataObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstFPObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstIntObjVar", pag); + readPAGNodesFromDB(connection, dbname, "ConstNullPtrObjVar", pag); + readPAGNodesFromDB(connection, dbname, "RetValPN", pag); + readPAGNodesFromDB(connection, dbname, "VarArgValPN", pag); + readPAGNodesFromDB(connection, dbname, "DummyValVar", pag); + readPAGNodesFromDB(connection, dbname, "DummyObjVar", pag); +} + +void GraphDBClient::updatePAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Updating SVF PAG nodes from DB....\n"; + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ArgValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "GepValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "BaseObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "GepObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "HeapObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "StackObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "FunObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "FunValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "GlobalValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstAggValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstDataValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "BlackHoleValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstFPValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstIntValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstNullPtrValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "GlobalObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstAggObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstDataObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstFPObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstIntObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstNullPtrObjVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "RetValPN", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "VarArgValPN", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "DummyValVar", pag); + updateSVFPAGNodesAttributesFromDB(connection, dbname, "DummyObjVar", pag); +} + +void GraphDBClient::updateSVFValVarAtrributes(cJSON* properties, ValVar* var, SVFIR* pag) +{ + int icfg_node_id = cJSON_GetObjectItem(properties, "icfg_node_id")->valueint; + if (icfg_node_id != -1) + { + ICFGNode* icfgNode = pag->getICFG()->getGNode(icfg_node_id); + if (nullptr != icfgNode) + { + var->updateSVFValVar(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFValVarAtrributes] No matching ICFGNode found for id: " << icfg_node_id << " when update SVFVar:"<getId()<<"\n"; + } + } +} + +void GraphDBClient::updateSVFBaseObjVarAtrributes(cJSON* properties, BaseObjVar* var, SVFIR* pag) +{ + int icfg_node_id = cJSON_GetObjectItem(properties, "icfg_node_id")->valueint; + if (icfg_node_id != -1) + { + ICFGNode* icfgNode = pag->getICFG()->getGNode(icfg_node_id); + if (nullptr != icfgNode) + { + var->setICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFValVarAtrributes] No matching ICFGNode found for id: " << icfg_node_id << " when update SVFVar:"<getId()<<"\n"; + } + } +} + +void GraphDBClient::updateFunObjVarAttributes(cJSON* properties, FunObjVar* var, SVFIR* pag) +{ + int real_def_fun_node_id = cJSON_GetObjectItem(properties, "real_def_fun_node_id")->valueint; + const FunObjVar* realDefFunNode = id2funObjVarsMap[real_def_fun_node_id]; + if (nullptr != realDefFunNode) + { + var->setRelDefFun(realDefFunNode); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching FunObjVar found for id: " << real_def_fun_node_id <<" when updating FunObjVar:"<getId()<< "\n"; + } + + int exit_bb_id = cJSON_GetObjectItem(properties, "exit_bb_id")->valueint; + if (exit_bb_id != -1) + { + SVFBasicBlock* exitBB = var->getBasicBlockGraph()->getGNode(exit_bb_id); + if (nullptr != exitBB) + { + var->updateExitBlock(exitBB); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << exit_bb_id <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + + SVFLoopAndDomInfo* loopAndDom = new SVFLoopAndDomInfo(); + var->setLoopAndDomInfo(loopAndDom); + + std::string reachable_bbs = cJSON_GetObjectItem(properties, "reachable_bbs")->valuestring; + std::string dt_bbs_map = cJSON_GetObjectItem(properties, "dt_bbs_map")->valuestring; + std::string pdt_bbs_map = cJSON_GetObjectItem(properties, "pdt_bbs_map")->valuestring; + std::string df_bbs_map = cJSON_GetObjectItem(properties, "df_bbs_map")->valuestring; + std::string bb2_loop_map = cJSON_GetObjectItem(properties, "bb2_loop_map")->valuestring; + std::string bb2_p_dom_level = cJSON_GetObjectItem(properties, "bb2_p_dom_level")->valuestring; + std::string bb2_pi_dom = cJSON_GetObjectItem(properties, "bb2_pi_dom")->valuestring; + + if (!reachable_bbs.empty()) + { + std::vector BBListVec = parseElements2Container>(reachable_bbs); + std::vector reachableBBs; + for (auto& bbId : BBListVec) + { + SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); + if (nullptr != bb) + { + reachableBBs.push_back(bb); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + loopAndDom->setReachableBBs(reachableBBs); + } + + if (!dt_bbs_map.empty()) + { + Map> dtBBsMap; + + Map> dt_bbs_map_ids = parseBBsMapFromString>>(dt_bbs_map); + for (auto& [bbId, bbSetIds] : dt_bbs_map_ids) + { + SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); + if (nullptr != bb) + { + Set dtBBSet; + for (auto& bbSetId : bbSetIds) + { + SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); + if (nullptr != bbSet) + { + dtBBSet.insert(bbSet); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + dtBBsMap[bb] = dtBBSet; + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + loopAndDom->setDomTreeMap(dtBBsMap); + } + + if (!pdt_bbs_map.empty()) + { + Map> pdtBBsMap; + + Map> pdt_bbs_map_ids = parseBBsMapFromString>>(pdt_bbs_map); + for (auto& [bbId, bbSetIds] : pdt_bbs_map_ids) + { + SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); + if (nullptr != bb) + { + Set pdtBBSet; + for (auto& bbSetId : bbSetIds) + { + SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); + if (nullptr != bbSet) + { + pdtBBSet.insert(bbSet); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + pdtBBsMap[bb] = pdtBBSet; + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + loopAndDom->setPostDomTreeMap(pdtBBsMap); + } + + if (!df_bbs_map.empty()) + { + Map> dfBBsMap; + + Map> df_bbs_map_ids = parseBBsMapFromString>>(df_bbs_map); + for (auto& [bbId, bbSetIds] : df_bbs_map_ids) + { + SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); + if (nullptr != bb) + { + Set dfBBSet; + for (auto& bbSetId : bbSetIds) + { + SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); + if (nullptr != bbSet) + { + dfBBSet.insert(bbSet); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + dfBBsMap[bb] = dfBBSet; + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + loopAndDom->setDomFrontierMap(dfBBsMap); + } + + if (!bb2_loop_map.empty()) + { + Map> bb2LoopMap; + + Map> bb2_loop_map_ids = parseBBsMapFromString>>(bb2_loop_map); + for (auto& [bbId, bbSetIds] : bb2_loop_map_ids) + { + SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); + if (nullptr != bb) + { + std::vector loopBBs; + for (auto& bbSetId : bbSetIds) + { + SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); + if (nullptr != bbSet) + { + loopBBs.push_back(bbSet); + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + bb2LoopMap[bb] = loopBBs; + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + loopAndDom->setBB2LoopMap(bb2LoopMap); + } + + if (!bb2_p_dom_level.empty()) + { + Map bb2PdomLevel; + Map bb2_p_dom_level_ids = parseLabelMapFromString>(bb2_p_dom_level); + for (auto& [bbId, value] : bb2_p_dom_level_ids) + { + SVFBasicBlock* bb = nullptr; + if (bbId != -1) + { + bb = var->getBasicBlockGraph()->getGNode(bbId); + } + if (nullptr != bb) + { + bb2PdomLevel[bb] = value; + } + else + { + SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; + } + } + + loopAndDom->setBB2PdomLevel(bb2PdomLevel); + } + + if (!bb2_pi_dom.empty()) + { + Map bb2PiDom; + + Map bb2_pi_dom_ids = parseBB2PiMapFromString>(bb2_pi_dom); + for (auto& [key,value] : bb2_pi_dom_ids) + { + SVFBasicBlock* keyBB = nullptr; + SVFBasicBlock* valueBB = nullptr; + if (key != -1) + { + keyBB = var->getBasicBlockGraph()->getGNode(key); + } + if (value != -1) + { + valueBB = var->getBasicBlockGraph()->getGNode(value); + } + bb2PiDom[keyBB] = valueBB; + } + loopAndDom->setBB2PIdom(bb2PiDom); + } +} +void GraphDBClient::updateGepValVarAttributes(cJSON* properties, GepValVar* var, SVFIR* pag) +{ + int base_val_id = cJSON_GetObjectItem(properties, "base_val_id")->valueint; + ValVar* baseVal = SVFUtil::dyn_cast(pag->getGNode(base_val_id)); + if (nullptr != baseVal) + { + var->setBaseNode(baseVal); + } + else + { + SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching ValVar found for id: " + << base_val_id << " when updating GepValVar:" << var->getId() + << "\n"; + } + s64_t fldIdx = cJSON_GetObjectItem(properties, "ap_fld_idx")->valueint; + cJSON* ap_gep_pointee_type_name_node = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_name"); + std::string ap_gep_pointee_type_name = ""; + if (nullptr != ap_gep_pointee_type_name_node && nullptr != ap_gep_pointee_type_name_node->valuestring) + { + ap_gep_pointee_type_name = ap_gep_pointee_type_name_node->valuestring; + } + const SVFType* gepPointeeType = nullptr; + if (!ap_gep_pointee_type_name.empty()) + { + gepPointeeType = pag->getSVFType(ap_gep_pointee_type_name); + } + AccessPath* ap = nullptr; + if (nullptr != gepPointeeType) + { + ap = new AccessPath(fldIdx, gepPointeeType); + } + else + { + ap = new AccessPath(fldIdx); + if (!ap_gep_pointee_type_name.empty()) + SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching SVFType found for ap_gep_pointee_type_name: " << ap_gep_pointee_type_name << " when updating GepValVar:"<getId()<< "\n"; + } + + cJSON* ap_idx_operand_pairs_node = cJSON_GetObjectItem(properties, "ap_idx_operand_pairs"); + std::string ap_idx_operand_pairs = ""; + if (nullptr != ap_idx_operand_pairs_node && nullptr != ap_idx_operand_pairs_node->valuestring) + { + ap_idx_operand_pairs = ap_idx_operand_pairs_node->valuestring; + } + parseAPIdxOperandPairsString(ap_idx_operand_pairs, pag, ap); + var->setAccessPath(ap); +} + +void GraphDBClient::parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap) +{ + if (!ap_idx_operand_pairs.empty()) + { + std::vector> pairVec = parseIdxOperandPairsString(ap_idx_operand_pairs); + for(auto& pair : pairVec) + { + int varId = pair.first; + std::string typeName = pair.second; + const SVFType* type; + if (typeName != "NULL") + { + type = pag->getSVFType(typeName); + if (nullptr == type) + { + SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching SVFType found for type: " << typeName << " when parsing IdxOperandPair\n"; + } + } + else + { + type = nullptr; + } + const SVFVar* var = pag->getGNode(varId); + if (nullptr != var) + { + std::pair pair = std::make_pair(var, type); + ap->addIdxOperandPair(pair); + } + else + { + SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching ValVar found for id: " << varId <<" when parsing IdxOperandPair \n"; + } + } + } +} + +void GraphDBClient::updateSVFPAGNodesAttributesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) +{ + std::string result; + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* node; + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + if (nodeType == "ConstNullPtrValVar") + { + ConstNullPtrValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstIntValVar") + { + ConstIntValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstFPValVar") + { + ConstFPValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ArgValVar") + { + ArgValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ArgValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int cg_node_id = cJSON_GetObjectItem(properties, "cg_node_id")->valueint; + FunObjVar* cgNode = id2funObjVarsMap[cg_node_id]; + if (nullptr != cgNode) + { + var->addCGNode(cgNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << cg_node_id <<" when updating ArgValVar:"<< id << "\n"; + } + } + else if (nodeType == "BlackHoleValVar") + { + BlackHoleValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BlackHoleValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstDataValVar") + { + ConstDataValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "RetValPN") + { + RetValPN* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching RetValPN found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; + FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; + if (nullptr != callGraphNode) + { + var->setCallGraphNode(callGraphNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating RetValPN:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching VarArgValPN found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; + FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; + if (nullptr != callGraphNode) + { + var->setCallGraphNode(callGraphNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating VarArgValPN:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstAggValVar") + { + ConstAggValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "GlobalValVar") + { + GlobalValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "FunValVar") + { + FunValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int fun_obj_var_node_id = cJSON_GetObjectItem(properties, "fun_obj_var_node_id")->valueint; + FunObjVar* funObjVar = id2funObjVarsMap[fun_obj_var_node_id]; + if (nullptr != funObjVar) + { + var->setFunction(funObjVar); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << fun_obj_var_node_id <<" when updating FunValVar:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GepValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + updateGepValVarAttributes(properties, var, pag); + + } + else if (nodeType == "ValVar") + { + ValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstNullPtrObjVar") + { + ConstNullPtrObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstIntObjVar") + { + ConstIntObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstFPObjVar") + { + ConstFPObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstDataObjVar") + { + ConstDataObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "DummyObjVar") + { + DummyObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "ConstAggObjVar") + { + ConstAggObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "GlobalObjVar") + { + GlobalObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "FunObjVar") + { + FunObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + updateFunObjVarAttributes(properties, var, pag); + } + else if (nodeType == "StackObjVar") + { + StackObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching StackObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "HeapObjVar") + { + HeapObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching HeapObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + else if (nodeType == "BaseObjVar") + { + BaseObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BaseObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + } + } + cJSON_Delete(root); + } +} + + +void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) +{ + std::string result; + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* node; + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type_name")->valuestring; + const SVFType* type = pag->getSVFType(svfTypeName); + if (type == nullptr) + { + SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching SVFType found for type: " << svfTypeName << "for PAGNode:"<addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstIntValVar") + { + u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); + s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; + ConstIntValVar* var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstFPValVar") + { + double dval = cJSON_GetObjectItem(properties, "dval")->valuedouble; + ConstFPValVar* var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ArgValVar") + { + u32_t arg_no = static_cast(cJSON_GetObjectItem(properties, "arg_no")->valueint); + ArgValVar* var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "BlackHoleValVar") + { + BlackHoleValVar* var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstDataValVar") + { + ConstDataValVar* var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "RetValPN") + { + RetValPN* var = new RetValPN(id, type, ValVar::RetValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "VarArgValPN") + { + VarArgValPN* var = new VarArgValPN(id, type, ValVar::VarargValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "DummyValVar") + { + DummyValVar* var = new DummyValVar(id, type, ValVar::DummyValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstAggValVar") + { + ConstAggValVar* var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "GlobalValVar") + { + GlobalValVar* var = new GlobalValVar(id, type, ValVar::GlobalValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "FunValVar") + { + FunValVar* var = new FunValVar(id, type, ValVar::FunValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "GepValVar") + { + std::string gep_val_svf_type_name = cJSON_GetObjectItem(properties, "gep_val_svf_type_name")->valuestring; + const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_name); + GepValVar* var = new GepValVar(id, type, gepValType, ValVar::GepValNode); + pag->addInitValNode(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ValVar") + { + ValVar* var = new ValVar(id, type, ValVar::ValNode); + pag->addValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstNullPtrObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstNullPtrObjVar* var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstIntObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); + s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; + ConstIntObjVar* var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstFPObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + float dval = (float)(cJSON_GetObjectItem(properties, "dval")->valuedouble); + ConstFPObjVar* var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstDataObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstDataObjVar* var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "DummyObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + DummyObjVar* var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); + pag->addDummyObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstAggObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstAggObjVar* var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "GlobalObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + GlobalObjVar* var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "FunObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + bool is_decl = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_decl")); + bool intrinsic = cJSON_IsTrue(cJSON_GetObjectItem(properties, "intrinsic")); + bool is_addr_taken = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_addr_taken")); + bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); + bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_return")); + bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); + std::string fun_type_name = cJSON_GetObjectItem(properties, "fun_type_name")->valuestring; + const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_name)); + FunObjVar* var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); + std::string all_args_node_ids = cJSON_GetObjectItem(properties, "all_args_node_ids")->valuestring; + if (!all_args_node_ids.empty()) + { + std::vector all_args_node_ids_vec = parseElements2Container>(all_args_node_ids); + for (int arg_id : all_args_node_ids_vec) + { + ArgValVar* arg = SVFUtil::dyn_cast(pag->getGNode(arg_id)); + if (arg != nullptr) + { + var->addArgument(arg); + } + else + { + SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching ArgValVar found for id: " << arg_id << "\n"; + } + } + } + pag->addBaseObjNode(var); + id2funObjVarsMap[id] = var; + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "StackObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + StackObjVar* var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "HeapObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + HeapObjVar* var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "BaseObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + BaseObjVar* var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); + pag->addBaseObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "GepObjVar") + { + s64_t app_offset = cJSON_GetObjectItem(properties, "app_offset")->valueint; + int base_obj_var_node_id = cJSON_GetObjectItem(properties, "base_obj_var_node_id")->valueint; + const BaseObjVar* baseObj = pag->getBaseObject(base_obj_var_node_id); + GepObjVar* var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); + pag->addGepObjNode(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ObjVar") + { + ObjVar* var = new ObjVar(id, type, ObjVar::ObjNode); + pag->addObjNodeFromDB(SVFUtil::cast(var)); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + } + cJSON_Delete(root); + } +} + +ObjTypeInfo* GraphDBClient::parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag) +{ + std::string obj_type_info_type_name = cJSON_GetObjectItem(properties, "obj_type_info_type_name")->valuestring; + const SVFType* objTypeInfoType = pag->getSVFType(obj_type_info_type_name); + int obj_type_info_flags = cJSON_GetObjectItem(properties, "obj_type_info_flags")->valueint; + int obj_type_info_max_offset_limit = cJSON_GetObjectItem(properties, "obj_type_info_max_offset_limit")->valueint; + int obj_type_info_elem_num = cJSON_GetObjectItem(properties, "obj_type_info_elem_num")->valueint; + int obj_type_info_byte_size = cJSON_GetObjectItem(properties, "obj_type_info_byte_size")->valueint; + ObjTypeInfo* objTypeInfo = new ObjTypeInfo(objTypeInfoType, obj_type_info_flags, obj_type_info_max_offset_limit, obj_type_info_elem_num, obj_type_info_byte_size); + if (nullptr != objTypeInfo) + return objTypeInfo; + return nullptr; +} + +cJSON* GraphDBClient::queryFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string queryStatement) +{ + // parse all SVFType + std::string result; + if (!connection->CallCypher(result, queryStatement, dbname)) + { + SVFUtil::outs() << queryStatement<< "\n"; + SVFUtil::outs() << "Failed to query from DB:" << result << "\n"; + return nullptr; + } + cJSON* root = cJSON_Parse(result.c_str()); + if (!root || !cJSON_IsArray(root)) + { + SVFUtil::outs() << "Invalid JSON format: "<getId(); + std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(id) +" RETURN node"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* node; + BasicBlockGraph* bbGraph = new BasicBlockGraph(); + funObjVar->setBasicBlockGraph(bbGraph); + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + std::string id = cJSON_GetObjectItem(properties, "id")->valuestring; + std::string bb_name = + cJSON_GetObjectItem(properties, "bb_name")->valuestring; + int bbId = parseBBId(id); + SVFBasicBlock* bb = new SVFBasicBlock(bbId, funObjVar); + bb->setName(bb_name); + bbGraph->addBasicBlock(bb); + basicBlocks.insert(bb); + } + cJSON_Delete(root); + } +} + +void GraphDBClient::readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) +{ + BasicBlockGraph* bbGraph = funObjVar->getBasicBlockGraph(); + if (nullptr != bbGraph) + { + for (auto& pair: *bbGraph) + { + SVFBasicBlock* bb = pair.second; + std::string queryStatement = "MATCH (node{id:'"+std::to_string(bb->getId())+":"+std::to_string(bb->getFunction()->getId())+"'}) RETURN node.pred_bb_ids, node.sscc_bb_ids"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* item; + cJSON_ArrayForEach(item, root) + { + if (!item) + continue; + std::string pred_bb_ids = cJSON_GetObjectItem(item, "node.pred_bb_ids")->valuestring; + std::string sscc_bb_ids = cJSON_GetObjectItem(item, "node.sscc_bb_ids")->valuestring; + if (!pred_bb_ids.empty()) + { + std::vector predBBIds = parseElements2Container>(pred_bb_ids); + for (int predBBId : predBBIds) + { + + SVFBasicBlock* predBB = bbGraph->getGNode(predBBId); + if (nullptr != predBB) + { + bb->addPredBasicBlock(predBB); + } + + } + } + if (!sscc_bb_ids.empty()) + { + std::vector ssccBBIds = parseElements2Container>(sscc_bb_ids); + for (int ssccBBId : ssccBBIds) + { + SVFBasicBlock* ssccBB = bbGraph->getGNode(ssccBBId); + if (nullptr != ssccBB) + { + bb->addSuccBasicBlock(ssccBB); + } + + } + } + } + cJSON_Delete(root); + } + } + } +} + +ICFG* GraphDBClient::buildICFGFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Build ICFG from DB....\n"; + DBOUT(DGENERAL, outs() << pasMsg("\t Building ICFG From DB ...\n")); + ICFG* icfg = new ICFG(); + // read & add all the ICFG nodes from DB + readICFGNodesFromDB(connection, dbname, "GlobalICFGNode", icfg, pag); + readICFGNodesFromDB(connection, dbname, "FunEntryICFGNode", icfg, pag); + readICFGNodesFromDB(connection, dbname, "FunExitICFGNode", icfg, pag); + readICFGNodesFromDB(connection, dbname, "IntraICFGNode", icfg, pag); + // need to parse the RetICFGNode first before parsing the CallICFGNode + readICFGNodesFromDB(connection, dbname, "RetICFGNode", icfg, pag); + readICFGNodesFromDB(connection, dbname, "CallICFGNode", icfg, pag); + + // read & add all the ICFG edges from DB + readICFGEdgesFromDB(connection, dbname, "IntraCFGEdge", icfg, pag); + readICFGEdgesFromDB(connection, dbname, "CallCFGEdge", icfg, pag); + readICFGEdgesFromDB(connection, dbname, "RetCFGEdge", icfg, pag); + + return icfg; +} + +void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, ICFG* icfg, SVFIR* pag) +{ + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* node; + cJSON_ArrayForEach(node, root) + { + ICFGNode* icfgNode = nullptr; + if (nodeType == "GlobalICFGNode") + { + icfgNode = parseGlobalICFGNodeFromDBResult(node); + if (nullptr != icfgNode) + { + icfg->addGlobalICFGNode(SVFUtil::cast(icfgNode)); + } + } + else if (nodeType == "IntraICFGNode") + { + icfgNode = parseIntraICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addIntraICFGNode(SVFUtil::cast(icfgNode)); + } + } + else if (nodeType == "FunEntryICFGNode") + { + icfgNode = parseFunEntryICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addFunEntryICFGNode(SVFUtil::cast(icfgNode)); + } + } + else if (nodeType == "FunExitICFGNode") + { + icfgNode = parseFunExitICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addFunExitICFGNode(SVFUtil::cast(icfgNode)); + } + } + else if (nodeType == "RetICFGNode") + { + icfgNode = parseRetICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addRetICFGNode(SVFUtil::cast(icfgNode)); + id2RetICFGNodeMap[icfgNode->getId()] = SVFUtil::cast(icfgNode); + } + } + else if (nodeType == "CallICFGNode") + { + icfgNode = parseCallICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addCallICFGNode(SVFUtil::cast(icfgNode)); + } + } + + if (nullptr == icfgNode) + { + SVFUtil::outs()<< "Failed to create "<< nodeType<< " from db query result\n"; + } + } + cJSON_Delete(root); + } +} + +ICFGNode* GraphDBClient::parseGlobalICFGNodeFromDBResult(const cJSON* node) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + GlobalICFGNode* icfgNode; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + + icfgNode = new GlobalICFGNode(id); + return icfgNode; +} + +ICFGNode* GraphDBClient::parseFunEntryICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + FunEntryICFGNode* icfgNode; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + } + + // parse FunEntryICFGNode bb + int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; + SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); + + icfgNode = new FunEntryICFGNode(id, funObjVar, bb); + std::string fpNodesStr = cJSON_GetObjectItem(properties, "fp_nodes")->valuestring; + std::vector fpNodesIdVec = parseElements2Container>(fpNodesStr); + for (auto fpNodeId: fpNodesIdVec) + { + SVFVar* fpNode = pag->getGNode(fpNodeId); + if (nullptr != fpNode) + { + pag->addFunArgs(SVFUtil::cast(icfgNode), funObjVar, fpNode); + } + else + { + SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching fpNode SVFVar found for id: " << fpNodeId << "\n"; + } + } + + if (nullptr != bb) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + } + + + return icfgNode; +} + +ICFGNode* GraphDBClient::parseFunExitICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + FunExitICFGNode* icfgNode; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + } + + // parse FunExitICFGNode bb + int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; + SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); + + icfgNode = new FunExitICFGNode(id, funObjVar, bb); + int formal_ret_node_id = cJSON_GetObjectItem(properties, "formal_ret_node_id")->valueint; + if (formal_ret_node_id != -1) + { + SVFVar* formalRet = pag->getGNode(formal_ret_node_id); + if (nullptr != formalRet) + { + pag->addFunRet(SVFUtil::cast(icfgNode), funObjVar, formalRet); + } + else + { + SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching formalRet SVFVar found for id: " << formal_ret_node_id << "\n"; + } + } + + if (nullptr != bb) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + } + + return icfgNode; +} + +ICFGNode* GraphDBClient::parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + IntraICFGNode* icfgNode; + int id = cJSON_GetObjectItem(properties, "id")->valueint; + // parse intraICFGNode funObjVar + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + } + + // parse intraICFGNode bb + int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; + SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); + + // parse isRet + bool is_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_return")); + + + icfgNode = new IntraICFGNode(id, bb, funObjVar, is_return); + + // add this ICFGNode to its BasicBlock + if (nullptr != bb) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + } + return icfgNode; +} + +ICFGNode* GraphDBClient::parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + RetICFGNode* icfgNode; + // parse retICFGNode id + int id = cJSON_GetObjectItem(properties, "id")->valueint; + + // parse retICFGNode funObjVar + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + } + + // parse retICFGNode bb + int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; + SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); + + // parse retICFGNode svfType + std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type")->valuestring; + const SVFType* type = pag->getSVFType(svfTypeName); + if (nullptr == type) + { + SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeName << "\n"; + } + + // create RetICFGNode Instance + icfgNode = new RetICFGNode(id, type, bb, funObjVar); + + // parse & add actualRet for RetICFGNode + int actual_ret_node_id = cJSON_GetObjectItem(properties, "actual_ret_node_id")->valueint; + if (actual_ret_node_id != -1) + { + SVFVar* actualRet = pag->getGNode(actual_ret_node_id); + if (nullptr != actualRet) + { + pag->addCallSiteRets(SVFUtil::cast(icfgNode), actualRet); + } + else + { + SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching actualRet SVFVar found for id: " << actual_ret_node_id << "\n"; + } + } + + // add this ICFGNode to its BasicBlock + if (nullptr != bb) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + } + return icfgNode; +} + +ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + CallICFGNode* icfgNode; + + // parse CallICFGNode id + int id = cJSON_GetObjectItem(properties, "id")->valueint; + + // parse CallICFGNode funObjVar + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + } + + // parse CallICFGNode bb + int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; + SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); + + // parse CallICFGNode svfType + std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type")->valuestring; + const SVFType* type = pag->getSVFType(svfTypeName); + if (nullptr == type) + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeName << "\n"; + } + + // parse CallICFGNode calledFunObjVar + int called_fun_obj_var_id = cJSON_GetObjectItem(properties, "called_fun_obj_var_id")->valueint; + FunObjVar* calledFunc = nullptr; + if (called_fun_obj_var_id != -1) + { + auto calledFuncIt = id2funObjVarsMap.find(called_fun_obj_var_id); + if (calledFuncIt != id2funObjVarsMap.end()) + { + calledFunc = calledFuncIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching calledFunObjVar found for id: " << called_fun_obj_var_id << "\n"; + } + } + + bool is_vararg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_vararg")); + bool is_vir_call_inst = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_vir_call_inst")); + + // parse CallICFGNode retICFGNode + int ret_icfg_node_id = cJSON_GetObjectItem(properties, "ret_icfg_node_id")->valueint; + RetICFGNode* retICFGNode = nullptr; + if (ret_icfg_node_id != -1) + { + auto retICFGNodeIt = id2RetICFGNodeMap.find(ret_icfg_node_id); + if (retICFGNodeIt != id2RetICFGNodeMap.end()) + { + retICFGNode = retICFGNodeIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching RetICFGNode found for id: " << ret_icfg_node_id << "\n"; + } + } + + std::string fun_name_of_v_call = ""; + s32_t virtualFunIdx = 0; + SVFVar* vtabPtr = nullptr; + if (is_vir_call_inst) + { + int virtual_fun_idx = cJSON_GetObjectItem(properties, "virtual_fun_idx")->valueint; + virtualFunIdx = static_cast(virtual_fun_idx); + int vtab_ptr_node_id = cJSON_GetObjectItem(properties, "vtab_ptr_node_id")->valueint; + vtabPtr = pag->getGNode(vtab_ptr_node_id); + fun_name_of_v_call = cJSON_GetObjectItem(properties, "fun_name_of_v_call")->valuestring; + } + + // create CallICFGNode Instance + icfgNode = new CallICFGNode(id, bb, type, funObjVar, calledFunc, retICFGNode, + is_vararg, is_vir_call_inst, virtualFunIdx, vtabPtr, fun_name_of_v_call); + + // parse CallICFGNode APNodes + std::string ap_nodes = cJSON_GetObjectItem(properties, "ap_nodes")->valuestring; + if (!ap_nodes.empty() && ap_nodes!= "[]") + { + std::vector apNodesIdVec = parseElements2Container>(ap_nodes); + if (apNodesIdVec.size() > 0) + { + for (auto apNodeId: apNodesIdVec) + { + SVFVar* apNode = pag->getGNode(apNodeId); + if (nullptr != apNode) + { + pag->addCallSiteArgs(SVFUtil::cast(icfgNode), SVFUtil::cast(apNode)); + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching APNode ValVar found for id: " << apNodeId << "\n"; + } + } + } + } + + if (retICFGNode != nullptr) + { + retICFGNode->addCallBlockNode(icfgNode); + } + + // add this ICFGNode to its BasicBlock + if (nullptr != bb) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + } + + return icfgNode; +} + +void GraphDBClient::readICFGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, ICFG* icfg, SVFIR* pag) +{ + std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* edge; + cJSON_ArrayForEach(edge, root) + { + ICFGEdge* icfgEdge = nullptr; + if (edgeType == "IntraCFGEdge") + { + icfgEdge = parseIntraCFGEdgeFromDBResult(edge, pag, icfg); + } + else if (edgeType == "CallCFGEdge") + { + icfgEdge = parseCallCFGEdgeFromDBResult(edge, pag, icfg); + } + else if (edgeType == "RetCFGEdge") + { + icfgEdge = parseRetCFGEdgeFromDBResult(edge, pag, icfg); + } + if (nullptr != icfgEdge) + { + icfg->addICFGEdge(icfgEdge); + } + else + { + SVFUtil::outs()<< "Failed to create "<< edgeType << " from db query result\n"; + } + } + cJSON_Delete(root); + } +} + +ICFGEdge* GraphDBClient::parseIntraCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) +{ + cJSON* data = cJSON_GetObjectItem(edge, "edge"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + IntraCFGEdge* icfgEdge; + + // parse srcICFGNode & dstICFGNode + int src_id = cJSON_GetObjectItem(data,"src")->valueint; + int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; + ICFGNode* src = icfg->getICFGNode(src_id); + ICFGNode* dst = icfg->getICFGNode(dst_id); + + if (src == nullptr) + { + SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; + return nullptr; + } + if (dst == nullptr) + { + SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; + return nullptr; + } + + // create IntraCFGEdge Instance + icfgEdge = new IntraCFGEdge(src, dst); + + // parse branchCondVal & conditionalVar + int condition_var_id = cJSON_GetObjectItem(properties, "condition_var_id")->valueint; + int branch_cond_val = cJSON_GetObjectItem(properties, "branch_cond_val")->valueint; + s64_t branchCondVal = 0; + SVFVar* conditionVar; + if (condition_var_id != -1 && branch_cond_val != -1) + { + branchCondVal = static_cast(branch_cond_val); + conditionVar = pag->getGNode(condition_var_id); + if (nullptr == conditionVar) + { + SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching conditionVar found for id: " << condition_var_id << "\n"; + } + icfgEdge->setConditionVar(conditionVar); + icfgEdge->setBranchCondVal(branchCondVal); + } + + return icfgEdge; +} + +ICFGEdge* GraphDBClient::parseCallCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) +{ + cJSON* data = cJSON_GetObjectItem(edge, "edge"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + CallCFGEdge* icfgEdge; + // parse srcICFGNode & dstICFGNode + int src_id = cJSON_GetObjectItem(data,"src")->valueint; + int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; + ICFGNode* src = icfg->getICFGNode(src_id); + ICFGNode* dst = icfg->getICFGNode(dst_id); + if (src == nullptr) + { + SVFUtil::outs() << "Warning: [parseCallCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; + return nullptr; + } + if (dst == nullptr) + { + SVFUtil::outs() << "Warning: [parseCallCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; + return nullptr; + } + + // create CallCFGEdge Instance + icfgEdge = new CallCFGEdge(src, dst); + std::string call_pe_ids = cJSON_GetObjectItem(properties, "call_pe_ids")->valuestring; + if (!call_pe_ids.empty()) + { + callCFGEdge2CallPEStrMap[icfgEdge] = call_pe_ids; + } + return icfgEdge; +} + +ICFGEdge* GraphDBClient::parseRetCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) +{ + cJSON* data = cJSON_GetObjectItem(edge, "edge"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + RetCFGEdge* icfgEdge; + // parse srcICFGNode & dstICFGNode + int src_id = cJSON_GetObjectItem(data,"src")->valueint; + int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; + ICFGNode* src = icfg->getICFGNode(src_id); + ICFGNode* dst = icfg->getICFGNode(dst_id); + if (src == nullptr) + { + SVFUtil::outs() << "Warning: [parseRetCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; + return nullptr; + } + if (dst == nullptr) + { + SVFUtil::outs() << "Warning: [parseRetCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; + return nullptr; + } + + // create RetCFGEdge Instance + icfgEdge = new RetCFGEdge(src, dst); + int ret_pe_id = cJSON_GetObjectItem(properties, "ret_pe_id")->valueint; + if (ret_pe_id != -1) + { + retCFGEdge2RetPEStrMap[icfgEdge] = ret_pe_id; + } + return icfgEdge; +} + +CallGraph* GraphDBClient::buildCallGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) +{ + SVFUtil::outs()<< "Build CallGraph from DB....\n"; + DBOUT(DGENERAL, outs() << pasMsg("\t Building CallGraph From DB ...\n")); + CallGraph* callGraph = new CallGraph(); + readCallGraphNodesFromDB(connection, dbname, callGraph); + readCallGraphEdgesFromDB(connection, dbname, pag, callGraph); + + return callGraph; +} + +void GraphDBClient::readCallGraphNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, CallGraph* callGraph) +{ + std::string queryStatement = " MATCH (node:CallGraphNode) RETURN node"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* node; + cJSON_ArrayForEach(node, root) + { + CallGraphNode* cgNode = nullptr; + cgNode = parseCallGraphNodeFromDB(node); + if (nullptr != cgNode) + { + callGraph->addCallGraphNodeFromDB(cgNode); + } + } + cJSON_Delete(root); + } +} + +void GraphDBClient::readCallGraphEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag, CallGraph* callGraph) +{ + std::string queryStatement = "MATCH ()-[edge]->() RETURN edge"; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) + { + cJSON* edge; + cJSON_ArrayForEach(edge, root) + { + CallGraphEdge* cgEdge = nullptr; + cgEdge = parseCallGraphEdgeFromDB(edge, pag, callGraph); + if (nullptr != cgEdge) + { + if (cgEdge->isDirectCallEdge()) + { + callGraph->addDirectCallGraphEdge(cgEdge); + } + if (cgEdge->isIndirectCallEdge()) + { + callGraph->addIndirectCallGraphEdge(cgEdge); + } + } + } + cJSON_Delete(root); + } +} + +CallGraphNode* GraphDBClient::parseCallGraphNodeFromDB(const cJSON* node) +{ + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + int id = cJSON_GetObjectItem(properties,"id")->valueint; + + // parse funObjVar + int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; + FunObjVar* funObjVar = nullptr; + auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); + if (funObjVarIt != id2funObjVarsMap.end()) + { + funObjVar = funObjVarIt->second; + } + else + { + SVFUtil::outs() << "Warning: [parseCallGraphNodeFromDB] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; + return nullptr; + } + CallGraphNode* cgNode; + + // create callGraph node instance + cgNode = new CallGraphNode(id, funObjVar); + + return cgNode; +} + +CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* pag, CallGraph* callGraph) +{ + CallGraphEdge* cgEdge = nullptr; + cJSON* data = cJSON_GetObjectItem(edge, "edge"); + if (!data) + return nullptr; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return nullptr; + + int src_id = cJSON_GetObjectItem(data,"src")->valueint; + int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; + int csid = cJSON_GetObjectItem(properties,"csid")->valueint; + std::string direct_call_set = cJSON_GetObjectItem(properties,"direct_call_set")->valuestring; + std::string indirect_call_set = cJSON_GetObjectItem(properties, "indirect_call_set")->valuestring; + + int kind = cJSON_GetObjectItem(properties, "kind")->valueint; + + CallGraphNode* srcNode = callGraph->getGNode(src_id); + CallGraphNode* dstNode = callGraph->getGNode(dst_id); + if (srcNode == nullptr) + { + SVFUtil::outs() << "Warning: [parseCallGraphEdgeFromDB] No matching src CallGraphNode found for id: " << src_id << "\n"; + return nullptr; + } + if (dstNode == nullptr) + { + SVFUtil::outs() << "Warning: [parseCallGraphEdgeFromDB] No matching dst CallGraphNode found for id: " << dst_id << "\n"; + return nullptr; + } + + // create CallGraphEdge Instance + cgEdge = new CallGraphEdge(srcNode, dstNode, static_cast(kind), csid); + Set direct_call_set_ids; + if (!direct_call_set.empty()) + { + direct_call_set_ids = parseElements2Container>(direct_call_set); + for (int directCallId : direct_call_set_ids) + { + CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(directCallId)); + callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); + cgEdge->addDirectCallSite(node); + pag->addCallSite(node); + callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); + } + } + + Set indirect_call_set_ids; + if (!indirect_call_set.empty()) + { + indirect_call_set_ids = parseElements2Container>(indirect_call_set); + for (int indirectCallId : indirect_call_set_ids) + { + CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(indirectCallId)); + callGraph->numOfResolvedIndCallEdge++; + callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); + cgEdge->addInDirectCallSite(node); + pag->addCallSite(node); + callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); + } + } + + return cgEdge; +} \ No newline at end of file diff --git a/svf/lib/SVFIR/SVFIR.cpp b/svf/lib/SVFIR/SVFIR.cpp index 1c51ff313..34abb0f24 100644 --- a/svf/lib/SVFIR/SVFIR.cpp +++ b/svf/lib/SVFIR/SVFIR.cpp @@ -74,6 +74,14 @@ AddrStmt* SVFIR::addAddrStmt(NodeID src, NodeID dst) return addrPE; } } +void SVFIR::addAddrStmt(AddrStmt* edge) +{ + if(!hasEdge(edge, SVFStmt::Addr)) + { + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); + } +} /*! * Add Copy edge @@ -93,6 +101,15 @@ CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type) } } +void SVFIR::addCopyStmt(CopyStmt* edge) +{ + if(!hasEdge(edge, SVFStmt::Copy)) + { + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); + } +} + /*! * Add Phi statement */ @@ -117,6 +134,19 @@ PhiStmt* SVFIR::addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred) } } +void SVFIR::addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst) +{ + SVFVar* opNode = src; + SVFVar* resNode = dst; + PHINodeMap::iterator it = phiNodeMap.find(resNode); + if (it == phiNodeMap.end()) + { + addToStmt2TypeMap(edge); + addEdge(opNode, resNode, edge); + phiNodeMap[resNode] = edge; + } +} + /*! * Add Phi statement */ @@ -138,6 +168,15 @@ SelectStmt* SVFIR::addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond } } +void SVFIR::addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst) +{ + if (!hasEdge(edge, SVFStmt::Select)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} + /*! * Add Compare edge */ @@ -158,6 +197,15 @@ CmpStmt* SVFIR::addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predicate) } } +void SVFIR::addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst) +{ + if (!hasEdge(edge,SVFStmt::Cmp)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} + /*! * Add Compare edge @@ -179,6 +227,14 @@ BinaryOPStmt* SVFIR::addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t o } } +void SVFIR::addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst) +{ + if (!hasEdge(edge, SVFStmt::BinaryOp)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} /*! * Add Unary edge */ @@ -197,6 +253,15 @@ UnaryOPStmt* SVFIR::addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode) } } +void SVFIR::addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst) +{ + if(!hasEdge(edge, SVFStmt::UnaryOp)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} + /* * Add BranchStmt */ @@ -215,6 +280,15 @@ BranchStmt* SVFIR::addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccA } } +void SVFIR::addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst) +{ + if(!hasEdge(edge, SVFStmt::Branch)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} + /*! * Add Load edge */ @@ -233,6 +307,15 @@ LoadStmt* SVFIR::addLoadStmt(NodeID src, NodeID dst) } } +void SVFIR::addLoadStmt(LoadStmt* edge) +{ + if(!hasEdge(edge, SVFStmt::Load)) + { + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); + } +} + /*! * Add Store edge * Note that two store instructions may share the same Store SVFStmt @@ -252,6 +335,15 @@ StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const ICFGNode* curVal) } } +void SVFIR::addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst) +{ + if(!hasEdge(edge,SVFStmt::Store)) + { + addToStmt2TypeMap(edge); + addEdge(src,dst, edge); + } +} + /*! * Add Call edge */ @@ -270,6 +362,15 @@ CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const F } } +void SVFIR::addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst) +{ + if(!hasEdge(edge, SVFStmt::Call)) + { + addToStmt2TypeMap(edge); + addEdge(src,dst, edge); + } +} + /*! * Add Return edge */ @@ -288,6 +389,15 @@ RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const Fun } } +void SVFIR::addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst) +{ + if(!hasEdge(edge, SVFStmt::Ret)) + { + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); + } +} + /*! * Add blackhole/constant edge */ @@ -375,6 +485,17 @@ GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap) } } +void SVFIR::addGepStmt(GepStmt* gepPE) +{ + SVFVar* baseNode = gepPE->getRHSVar(); + SVFVar* dstNode = gepPE->getLHSVar(); + if (!hasEdge(gepPE, SVFStmt::Gep)) + { + addToStmt2TypeMap(gepPE); + addEdge(baseNode, dstNode, gepPE); + } +} + /*! * Add variant(Gep) edge * Find the base node id of src and connect base node to dst node @@ -460,6 +581,17 @@ NodeID SVFIR::getGepObjVar(const BaseObjVar* baseObj, const APOffset& apOffset) } +void SVFIR::addGepObjNode(GepObjVar* gepObj) +{ + NodeID base = gepObj->getBaseNode(); + APOffset apOffset = gepObj->getConstantFieldIdx(); + assert(0==GepObjVarMap.count(std::make_pair(base, apOffset)) + && "this node should not be created before"); + GepObjVarMap[std::make_pair(base, apOffset)] = gepObj->getId(); + memToFieldsMap[base].set(gepObj->getId()); + addObjNode(gepObj); +} + /*! * Add a field obj node, this method can only invoked by getGepObjVar */ diff --git a/svf/lib/SVFIR/SVFStatements.cpp b/svf/lib/SVFIR/SVFStatements.cpp index f9eb02a0c..486631c1b 100644 --- a/svf/lib/SVFIR/SVFStatements.cpp +++ b/svf/lib/SVFIR/SVFStatements.cpp @@ -55,6 +55,16 @@ SVFStmt::SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real) : } } +SVFStmt::SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, bool real) : +GenericPAGEdgeTy(s,d,k),value(value),basicBlock(nullptr),icfgNode(icfgNode),edgeId(eid) +{ + if(real) + { + edgeId = eid; + SVFIR::getPAG()->incEdgeNum(); + } +} + /*! * Whether src and dst nodes are both pointer type */ @@ -329,6 +339,8 @@ StoreStmt::StoreStmt(SVFVar* s, SVFVar* d, const ICFGNode* st) : AssignStmt(s, d, makeEdgeFlagWithStoreInst(SVFStmt::Store, st)) { } +StoreStmt::StoreStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode) +: AssignStmt(s, d, k, eid, value, icfgNode) {} CallPE::CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, const FunEntryICFGNode* e, GEdgeKind k) @@ -336,12 +348,21 @@ CallPE::CallPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, { } +CallPE::CallPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunEntryICFGNode* entry): AssignStmt(s, d, k, eid, value, icfgNode), call(call), entry(entry) +{ + +} + RetPE::RetPE(SVFVar* s, SVFVar* d, const CallICFGNode* i, const FunExitICFGNode* e, GEdgeKind k) : AssignStmt(s, d, makeEdgeFlagWithCallInst(k, i)), call(i), exit(e) { } +RetPE::RetPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, + const FunExitICFGNode* exit): AssignStmt(s, d, k, eid, value, icfgNode), call(call), exit(exit) {} + MultiOpndStmt::MultiOpndStmt(SVFVar* r, const OPVars& opnds, GEdgeFlag k) : SVFStmt(opnds.at(0), r, k), opVars(opnds) { @@ -355,6 +376,12 @@ CmpStmt::CmpStmt(SVFVar* s, const OPVars& opnds, u32_t pre) assert(opnds.size() == 2 && "CmpStmt can only have two operands!"); } +CmpStmt::CmpStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t predicate, ICFGNode* icfgNode, const OPVars& opnds) +: MultiOpndStmt(s, d, k, eid, value, icfgNode, opnds), predicate(predicate) +{ + assert(opnds.size() == 2 && "CmpStmt can only have two operands!"); +} + SelectStmt::SelectStmt(SVFVar* s, const OPVars& opnds, const SVFVar* cond) : MultiOpndStmt(s, opnds, makeEdgeFlagWithAddionalOpnd(SVFStmt::Select, opnds.at(1))), @@ -363,6 +390,12 @@ SelectStmt::SelectStmt(SVFVar* s, const OPVars& opnds, const SVFVar* cond) assert(opnds.size() == 2 && "SelectStmt can only have two operands!"); } +SelectStmt::SelectStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, SVFVar* condition, ICFGNode* icfgNode, const OPVars& opnds) + : MultiOpndStmt(s, d, k, eid, value, icfgNode, opnds), condition(condition) +{ + assert(opnds.size() == 2 && "SelectStmt can only have two operands!"); +} + BinaryOPStmt::BinaryOPStmt(SVFVar* s, const OPVars& opnds, u32_t oc) : MultiOpndStmt( s, opnds, @@ -371,3 +404,9 @@ BinaryOPStmt::BinaryOPStmt(SVFVar* s, const OPVars& opnds, u32_t oc) { assert(opnds.size() == 2 && "BinaryOPStmt can only have two operands!"); } + +BinaryOPStmt::BinaryOPStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, u32_t opcode, ICFGNode* icfgNode, const OPVars& opnds) + : MultiOpndStmt(s, d, k, eid, value, icfgNode, opnds), opcode(opcode) +{ + assert(opnds.size() == 2 && "BinaryOPStmt can only have two operands!"); +} From d9489a2b12093b7dfb24d27a18cced51cb740de7 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 19 May 2025 10:14:04 +1000 Subject: [PATCH 03/19] - page query for graphs - rename graphdb related function name refactoring node/edge db insertStmt update ICFGNodes attrubuites --- svf/include/Graphs/BasicBlockG.h | 6 +- svf/include/Graphs/CallGraph.h | 6 +- .../Graphs/DBSchema/ICFGNodeSchema.json | 42 + svf/include/Graphs/ICFG.h | 12 +- svf/include/Graphs/ICFGEdge.h | 6 + svf/include/Graphs/ICFGNode.h | 16 +- svf/include/Graphs/IRGraph.h | 1 + svf/include/SVFIR/GraphDBClient.h | 94 - svf/include/SVFIR/SVFIR.h | 42 +- svf/include/SVFIR/SVFStatements.h | 44 + svf/include/SVFIR/SVFVariables.h | 69 +- svf/lib/Graphs/BasicBlockG.cpp | 23 + svf/lib/Graphs/ICFG.cpp | 190 ++ svf/lib/SVFIR/GraphDBClient.cpp | 2766 +++++------------ svf/lib/SVFIR/SVFIR.cpp | 28 +- svf/lib/SVFIR/SVFStatements.cpp | 461 +++ svf/lib/SVFIR/SVFVariables.cpp | 366 +++ 17 files changed, 2114 insertions(+), 2058 deletions(-) diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index dffc66f06..b6a1213b4 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -63,6 +63,8 @@ class BasicBlockEdge: public GenericBasicBlockEdgeTy //@} virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -293,6 +295,8 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy return predBBs; } + std::string toDBString() const; + }; @@ -319,7 +323,7 @@ class BasicBlockGraph: public GenericBasicBlockGraphTy return bb; } - void addBasicBlock(SVFBasicBlock* bb) + void addBasicBlockFromDB(SVFBasicBlock* bb) { id++; addGNode(bb->getId(), bb); diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index f01284722..27120d079 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -290,7 +290,7 @@ class CallGraph : public GenericPTACallGraphTy return it->second; } - inline void addCallSite(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid) + inline void addCallSiteFromDB(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid) { std::pair newCS(std::make_pair(cs, callee)); CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS); @@ -366,7 +366,7 @@ class CallGraph : public GenericPTACallGraphTy /// Add direct call edges void addDirectCallGraphEdge(const CallICFGNode* call, const FunObjVar* callerFun, const FunObjVar* calleeFun); - void addDirectCallGraphEdge(CallGraphEdge* cgEdge); + void addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); void addCallGraphNode(const FunObjVar* fun); @@ -470,7 +470,7 @@ class CallGraph : public GenericPTACallGraphTy /// Add indirect call edges //@{ void addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* callerFun, const FunObjVar* calleeFun); - void addIndirectCallGraphEdge(CallGraphEdge* cgEdge); + void addIndirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); //@} /// Get callsites invoking the callee diff --git a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json index 28d86567d..ee3b7bb00 100644 --- a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json @@ -16,6 +16,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -53,6 +59,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -72,6 +84,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -109,6 +127,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -146,6 +170,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -231,6 +261,12 @@ "type":"STRING", "optional":true, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -280,6 +316,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"pag_edge_ids", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/ICFG.h b/svf/include/Graphs/ICFG.h index 57793946c..bce0b06da 100644 --- a/svf/include/Graphs/ICFG.h +++ b/svf/include/Graphs/ICFG.h @@ -175,7 +175,7 @@ class ICFG : public GenericICFGTy return intraIcfgNode; } - virtual inline void addIntraICFGNode(IntraICFGNode* intraICFGNode) + virtual inline void addIntraICFGNodeFromDB(IntraICFGNode* intraICFGNode) { totalICFGNode++; addICFGNode(intraICFGNode); @@ -194,7 +194,7 @@ class ICFG : public GenericICFGTy return callICFGNode; } - virtual inline void addCallICFGNode(CallICFGNode* callICFGNode) + virtual inline void addCallICFGNodeFromDB(CallICFGNode* callICFGNode) { totalICFGNode++; addICFGNode(callICFGNode); @@ -207,7 +207,7 @@ class ICFG : public GenericICFGTy addICFGNode(retICFGNode); return retICFGNode; } - virtual inline void addRetICFGNode(RetICFGNode* retICFGNode) + virtual inline void addRetICFGNodeFromDB(RetICFGNode* retICFGNode) { totalICFGNode++; addICFGNode(retICFGNode); @@ -220,14 +220,14 @@ class ICFG : public GenericICFGTy return FunToFunEntryNodeMap[svfFunc] = sNode; } - virtual inline void addFunEntryICFGNode(FunEntryICFGNode* funEntryICFGNode) + virtual inline void addFunEntryICFGNodeFromDB(FunEntryICFGNode* funEntryICFGNode) { totalICFGNode++; addICFGNode(funEntryICFGNode); FunToFunEntryNodeMap[funEntryICFGNode->getFun()] = funEntryICFGNode; } - virtual inline void addGlobalICFGNode(GlobalICFGNode* globalICFGNode) + virtual inline void addGlobalICFGNodeFromDB(GlobalICFGNode* globalICFGNode) { totalICFGNode++; this->globalBlockNode = globalICFGNode; @@ -241,7 +241,7 @@ class ICFG : public GenericICFGTy return FunToFunExitNodeMap[svfFunc] = sNode; } - virtual inline void addFunExitICFGNode(FunExitICFGNode* funExitICFGNode) + virtual inline void addFunExitICFGNodeFromDB(FunExitICFGNode* funExitICFGNode) { totalICFGNode++; addICFGNode(funExitICFGNode); diff --git a/svf/include/Graphs/ICFGEdge.h b/svf/include/Graphs/ICFGEdge.h index 233ec4110..eed3c13a0 100644 --- a/svf/include/Graphs/ICFGEdge.h +++ b/svf/include/Graphs/ICFGEdge.h @@ -171,6 +171,8 @@ class IntraCFGEdge : public ICFGEdge { branchCondVal = bVal; } + + std::string toDBString() const; }; /*! @@ -220,6 +222,8 @@ class CallCFGEdge : public ICFGEdge } //@} virtual const std::string toString() const; + + std::string toDBString() const; }; /*! @@ -267,6 +271,8 @@ class RetCFGEdge : public ICFGEdge } //@} virtual const std::string toString() const; + + std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index dc2928b79..b6d7510f7 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -185,6 +185,8 @@ class GlobalICFGNode : public ICFGNode { return "Global ICFGNode"; } + + std::string toDBString() const; }; /*! @@ -236,6 +238,8 @@ class IntraICFGNode : public ICFGNode { return isRet; } + + std::string toDBString() const; }; class InterICFGNode : public ICFGNode @@ -269,6 +273,8 @@ class InterICFGNode : public ICFGNode return isInterICFGNodeKind(node->getNodeKind()); } + std::string toDBString() const; + //@} }; @@ -347,6 +353,8 @@ class FunEntryICFGNode : public InterICFGNode const std::string toString() const override; const std::string getSourceLoc() const override; + + std::string toDBString() const; }; /*! @@ -419,6 +427,8 @@ class FunExitICFGNode : public InterICFGNode const std::string toString() const override; const std::string getSourceLoc() const override; + + std::string toDBString() const; }; /*! @@ -606,6 +616,8 @@ class CallICFGNode : public InterICFGNode { return "CallICFGNode: " + ICFGNode::getSourceLoc(); } + + std::string toDBString() const; }; @@ -654,7 +666,7 @@ class RetICFGNode : public InterICFGNode actualRet = ar; } - inline void addCallBlockNode(const CallICFGNode* cb) + inline void addCallBlockNodeFromDB(const CallICFGNode* cb) { callBlockNode = cb; } @@ -692,6 +704,8 @@ class RetICFGNode : public InterICFGNode { return "RetICFGNode: " + ICFGNode::getSourceLoc(); } + + std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/include/Graphs/IRGraph.h b/svf/include/Graphs/IRGraph.h index b10f29933..5de5fb3a6 100644 --- a/svf/include/Graphs/IRGraph.h +++ b/svf/include/Graphs/IRGraph.h @@ -52,6 +52,7 @@ class IRGraph : public GenericGraph { friend class SVFIRBuilder; friend class SymbolTableBuilder; + friend class GraphDBClient; public: diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 1321cc39e..52fc205eb 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -112,102 +112,8 @@ class GraphDBClient std::string getPAGNodeKindString(const SVFVar* node); /// parse ICFGNodes & generate the insert statement for ICFGNodes - std::string getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node); - std::string getIntraICFGNodeInsertStmt(const IntraICFGNode* node); - std::string getInterICFGNodeInsertStmt(const InterICFGNode* node); - std::string getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node); - std::string getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node); - std::string getCallICFGNodeInsertStmt(const CallICFGNode* node); - std::string getRetICFGNodeInsertStmt(const RetICFGNode* node); - std::string getIntraCFGEdgeStmt(const IntraCFGEdge* edge); - std::string getCallCFGEdgeStmt(const CallCFGEdge* edge); - std::string getRetCFGEdgeStmt(const RetCFGEdge* edge); std::string getICFGNodeKindString(const ICFGNode* node); - /// parse and generate the node insert statement for SVFType nodes - std::string getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node); - std::string getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node); - std::string getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node); - std::string getSVFSturctTypeNodeInsertStmt(const SVFStructType* node); - std::string getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node); - std::string getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node); - std::string getStInfoNodeInsertStmt(const StInfo* node); - - /// parse and generate the node insert statement for valvar nodes - std::string getSVFVarNodeFieldsStmt(const SVFVar* node); - std::string getValVarNodeFieldsStmt(const ValVar* node); - std::string getValVarNodeInsertStmt(const ValVar* node); - std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node); - /// ConstDataValVar and its sub-class - std::string getConstDataValVarNodeInsertStmt(const ConstDataValVar* node); - std::string getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node); - std::string getConstFPValVarNodeInsertStmt(const ConstFPValVar* node); - std::string getConstIntValVarNodeInsertStmt(const ConstIntValVar* node); - std::string getConstNullPtrValVarNodeInsertStmt( - const ConstNullPtrValVar* node); - // parse and generate the node insert statement for valvar sub-class - std::string getRetValPNNodeInsertStmt(const RetValPN* node); - std::string getVarArgValPNNodeInsertStmt(const VarArgValPN* node); - std::string getDummyValVarNodeInsertStmt(const DummyValVar* node); - std::string getConstAggValVarNodeInsertStmt(const ConstAggValVar* node); - std::string getGlobalValVarNodeInsertStmt(const GlobalValVar* node); - std::string getFunValVarNodeInsertStmt(const FunValVar* node); - std::string getGepValVarNodeInsertStmt(const GepValVar* node); - std::string getArgValVarNodeInsertStmt(const ArgValVar* node); - - /// parse and generate the node insert statement for objvar nodes - std::string getObjVarNodeFieldsStmt(const ObjVar* node); - std::string getObjVarNodeInsertStmt(const ObjVar* node); - std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* node); - std::string getBaseObjNodeInsertStmt(const BaseObjVar* node); - std::string getGepObjVarNodeInsertStmt(const GepObjVar* node); - - /// parse and generate the node insert statement for baseObjVar sub-class - std::string getHeapObjVarNodeInsertStmt(const HeapObjVar* node); - std::string getStackObjVarNodeInsertStmt(const StackObjVar* node); - std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node); - std::string getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node); - std::string getConstNullPtrObjVarNodeInsertStmt( - const ConstNullPtrObjVar* node); - std::string getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node); - std::string getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node); - std::string getDummyObjVarNodeInsertStmt(const DummyObjVar* node); - std::string getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node); - std::string getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node); - std::string getFunObjVarNodeInsertStmt(const FunObjVar* node); - - /// parse and generate the edge insert statement for SVFStmt - std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge); - std::string generateSVFStmtEdgeInsertStmt(const SVFStmt* edge); - /// parse and generate the edge insert statement for AssignStmt & its - /// sub-class - std::string generateAssignStmtFieldsStmt(const AssignStmt* edge); - std::string generateAssignStmtEdgeInsertStmt(const AssignStmt* edge); - std::string generateAddrStmtEdgeInsertStmt(const AddrStmt* edge); - std::string generateCopyStmtEdgeInsertStmt(const CopyStmt* edge); - std::string generateStoreStmtEdgeInsertStmt(const StoreStmt* edge); - std::string generateLoadStmtEdgeInsertStmt(const LoadStmt* edge); - std::string generateGepStmtEdgeInsertStmt(const GepStmt* edge); - std::string generateCallPEEdgeInsertStmt(const CallPE* edge); - std::string generateRetPEEdgeInsertStmt(const RetPE* edge); - std::string generateTDForkPEEdgeInsertStmt(const TDForkPE* edge); - std::string generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge); - /// parse and generate the edge insert statement for MultiOpndStmt & its - /// sub-class - std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge); - std::string generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge); - std::string generatePhiStmtEdgeInsertStmt(const PhiStmt* edge); - std::string generateSelectStmtEndgeInsertStmt(const SelectStmt* edge); - std::string generateCmpStmtEdgeInsertStmt(const CmpStmt* edge); - std::string generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge); - std::string genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge); - std::string generateBranchStmtEdgeInsertStmt(const BranchStmt* edge); - - /// parse and generate the insert statement for BasicBlockGraph - std::string getBBNodeInsertStmt(const SVFBasicBlock* node); - std::string getBBEdgeInsertStmt(const BasicBlockEdge* edge); - - cJSON* queryFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string queryStatement); /// read SVFType from DB void readSVFTypesFromDB(lgraph::RpcClient* connection, diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index 6cf95fdee..55ebc6d4f 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -509,7 +509,7 @@ class SVFIR : public IRGraph if (hasGNode(node->getId())) { ValVar* valvar = SVFUtil::cast(getGNode(node->getId())); - valvar->updateSVFValVar(node->getType(), node->getICFGNode()); + valvar->updateSVFValVarFromDB(node->getType(), node->getICFGNode()); return valvar->getId(); } return addNode(node); @@ -521,24 +521,24 @@ class SVFIR : public IRGraph if (hasGNode(node->getId())) { ObjVar* objVar = SVFUtil::cast(getGNode(node->getId())); - objVar->updateObjVar(node->getType()); + objVar->updateObjVarFromDB(node->getType()); return objVar->getId(); } return addNode(node); } - inline NodeID addInitValNode(ValVar* node) + inline NodeID addInitValNodeFromDB(ValVar* node) { return addValNode(node); } - inline NodeID addBaseObjNode(BaseObjVar* node) + inline NodeID addBaseObjNodeFromDB(BaseObjVar* node) { memToFieldsMap[node->getId()].set(node->getId()); return addObjNode(node); } - inline NodeID addDummyObjNode(DummyObjVar* node) + inline NodeID addDummyObjNodeFromDB(DummyObjVar* node) { if (idToObjTypeInfoMap().find(node->getId()) == idToObjTypeInfoMap().end()) { @@ -552,7 +552,7 @@ class SVFIR : public IRGraph } } - void addGepObjNode(GepObjVar* gepObj); + void addGepObjNodeFromDB(GepObjVar* gepObj); private: @@ -579,7 +579,7 @@ class SVFIR : public IRGraph funArgsListMap[fun].push_back(arg); } - inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, FunObjVar* fun, const SVFVar* arg) + inline void addFunArgsFromDB(FunEntryICFGNode* funEntryBlockNode, FunObjVar* fun, const SVFVar* arg) { funEntryBlockNode->addFormalParms(arg); funArgsListMap[fun].push_back(arg); @@ -592,7 +592,7 @@ class SVFIR : public IRGraph funRetMap[fun] = ret; } - inline void addFunRet(FunExitICFGNode* funExitBlockNode, FunObjVar* fun, const SVFVar* ret) + inline void addFunRetFromDB(FunExitICFGNode* funExitBlockNode, FunObjVar* fun, const SVFVar* ret) { funExitBlockNode->addFormalRet(ret); funRetMap[fun] = ret; @@ -861,49 +861,49 @@ class SVFIR : public IRGraph //@{ /// Add Address edge AddrStmt* addAddrStmt(NodeID src, NodeID dst); - void addAddrStmt(AddrStmt* edge); + void addAddrStmtFromDB(AddrStmt* edge); /// Add Copy edge CopyStmt* addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type); - void addCopyStmt(CopyStmt* edge); + void addCopyStmtFromDB(CopyStmt* edge); /// Add phi node information PhiStmt* addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred); - void addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst); + void addPhiStmtFromDB(PhiStmt* edge, SVFVar* src, SVFVar* dst); /// Add SelectStmt SelectStmt* addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond); - void addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst); + void addSelectStmtFromDB(SelectStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge CmpStmt* addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predict); - void addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst); + void addCmpStmtFromDB(CmpStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge BinaryOPStmt* addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t opcode); - void addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst); + void addBinaryOPStmtFromDB(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add Unary edge UnaryOPStmt* addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode); - void addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst); + void addUnaryOPStmtFromDB(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add BranchStmt BranchStmt* addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs); - void addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst); + void addBranchStmtFromDB(BranchStmt* edge, SVFVar* src, SVFVar* dst); /// Add Load edge LoadStmt* addLoadStmt(NodeID src, NodeID dst); - void addLoadStmt(LoadStmt* edge); + void addLoadStmtFromDB(LoadStmt* edge); /// Add Store edge StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val); - void addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst); + void addStoreStmtFromDB(StoreStmt* edge, SVFVar* src, SVFVar* dst); /// Add Call edge CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunEntryICFGNode* entry); - void addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst); + void addCallPEFromDB(CallPE* edge, SVFVar* src, SVFVar* dst); /// Add Return edge RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunExitICFGNode* exit); - void addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst); + void addRetPEFromDB(RetPE* edge, SVFVar* src, SVFVar* dst); /// Add Gep edge GepStmt* addGepStmt(NodeID src, NodeID dst, const AccessPath& ap, bool constGep); - void addGepStmt(GepStmt* edge); + void addGepStmtFromDB(GepStmt* edge); /// Add Offset(Gep) edge GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap); /// Add Variant(Gep) edge diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index 0b1c191b3..29d6ceb4e 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -286,6 +286,10 @@ class SVFStmt : public GenericPAGEdgeTy return &multiOpndLabelCounter; } + std::string generateSVFStmtEdgeFieldsStmt() const; + + std::string toDBString() const; + }; /* @@ -369,6 +373,13 @@ class AssignStmt : public SVFStmt } virtual const std::string toString() const = 0; + + std::string generateAssignStmtFieldsStmt() const + { + return generateSVFStmtEdgeFieldsStmt(); + } + + std::string toDBString() const; }; /*! @@ -420,6 +431,8 @@ class AddrStmt: public AssignStmt return arrSize; } + std::string toDBString() const; + }; /*! @@ -508,6 +521,8 @@ class CopyStmt: public AssignStmt CopyStmt(SVFVar* s, SVFVar* d, CopyKind k) : AssignStmt(s, d, SVFStmt::Copy), copyKind(k) {} virtual const std::string toString() const override; + + std::string toDBString() const; private: u32_t copyKind; }; @@ -547,6 +562,8 @@ class StoreStmt: public AssignStmt StoreStmt(SVFVar* s, SVFVar* d, const ICFGNode* st); virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -584,6 +601,8 @@ class LoadStmt: public AssignStmt LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Load) {} virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -670,6 +689,8 @@ class GepStmt: public AssignStmt virtual const std::string toString() const; + std::string toDBString() const; + }; @@ -733,6 +754,7 @@ class CallPE: public AssignStmt //@} virtual const std::string toString() const override; + std::string toDBString() const; }; /*! @@ -795,6 +817,8 @@ class RetPE: public AssignStmt //@} virtual const std::string toString() const override; + + std::string toDBString() const; }; /* @@ -880,6 +904,10 @@ class MultiOpndStmt : public SVFStmt { return opVars.end(); } + + std::string generateMultiOpndStmtEdgeFieldsStmt() const; + + std::string toDBString() const; //@} }; @@ -963,6 +991,8 @@ class PhiStmt: public MultiOpndStmt bool isFunctionRetPhi() const; virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -1019,6 +1049,8 @@ class SelectStmt: public MultiOpndStmt { return getOpVar(1); } + + std::string toDBString() const; }; /*! @@ -1105,6 +1137,8 @@ class CmpStmt: public MultiOpndStmt } virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -1175,6 +1209,8 @@ class BinaryOPStmt: public MultiOpndStmt } virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -1243,6 +1279,8 @@ class UnaryOPStmt: public SVFStmt NodeID getResID() const; virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -1334,6 +1372,8 @@ BranchStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, SuccAnd } //@} virtual const std::string toString() const override; + + std::string toDBString() const; }; /*! @@ -1376,6 +1416,8 @@ class TDForkPE: public CallPE } virtual const std::string toString() const; + + std::string toDBString() const; }; /*! @@ -1419,6 +1461,8 @@ class TDJoinPE: public RetPE } virtual const std::string toString() const; + + std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index f33104c6a..64e334f50 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -248,6 +248,8 @@ class SVFVar : public GenericPAGNodeTy o << node.toString(); return o; } + + std::string getSVFVarNodeFieldsStmt() const; }; @@ -274,12 +276,12 @@ class ValVar: public SVFVar public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ - inline void updateSVFValVar(const SVFType* type, const ICFGNode* icfgNode) + inline void updateSVFValVarFromDB(const SVFType* type, const ICFGNode* icfgNode) { this->type = type; this->icfgNode = icfgNode; } - inline void updateSVFValVar(const ICFGNode* icfgNode) + inline void updateSVFValVarFromDB(const ICFGNode* icfgNode) { this->icfgNode = icfgNode; } @@ -320,6 +322,10 @@ class ValVar: public SVFVar virtual const FunObjVar* getFunction() const; virtual const std::string toString() const; + + std::string getValVarNodeFieldsStmt() const; + + std::string toDBString() const; }; /* @@ -338,7 +344,7 @@ class ObjVar: public SVFVar { } public: - void updateObjVar(const SVFType* type) + void updateObjVarFromDB(const SVFType* type) { this->type = type; } @@ -369,6 +375,10 @@ class ObjVar: public SVFVar } virtual const std::string toString() const; + + std::string getObjVarNodeFieldsStmt() const; + + std::string toDBString() const; }; @@ -426,7 +436,7 @@ class ArgValVar: public ValVar return getName() + " (argument valvar)"; } - inline void addCGNode(const FunObjVar* cgNode) + inline void addCGNodeFromDB(const FunObjVar* cgNode) { this->cgNode = cgNode; } @@ -447,6 +457,8 @@ class ArgValVar: public ValVar virtual bool isPointer() const; virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -559,6 +571,8 @@ class GepValVar: public ValVar { return base->isConstDataOrAggData(); } + + std::string toDBString() const; }; /* @@ -782,6 +796,10 @@ class BaseObjVar : public ObjVar virtual const FunObjVar* getFunction() const; + std::string getBaseObjVarNodeFieldsStmt() const; + + std::string toDBString() const; + }; @@ -887,6 +905,8 @@ class GepObjVar: public ObjVar { return base->isPointer(); } + + std::string toDBString() const; }; @@ -949,6 +969,8 @@ class HeapObjVar: public BaseObjVar } virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -1013,6 +1035,8 @@ class StackObjVar: public BaseObjVar } virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -1312,6 +1336,8 @@ class FunObjVar : public BaseObjVar virtual bool isIsolatedNode() const; virtual const std::string toString() const; + + std::string toDBString() const; }; class FunValVar : public ValVar { @@ -1369,6 +1395,8 @@ class FunValVar : public ValVar funObjVar = cgn; } virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -1415,6 +1443,8 @@ class GlobalValVar : public ValVar virtual const std::string toString() const; + + std::string toDBString() const; }; class ConstAggValVar: public ValVar @@ -1469,6 +1499,8 @@ class ConstAggValVar: public ValVar } virtual const std::string toString() const; + + std::string toDBString() const; }; @@ -1531,6 +1563,9 @@ class ConstDataValVar : public ValVar } virtual const std::string toString() const; + + std::string getConstDataValVarNodeFieldsStmt() const; + std::string toDBString() const; }; class BlackHoleValVar : public ConstDataValVar @@ -1581,6 +1616,8 @@ class BlackHoleValVar : public ConstDataValVar { return "BlackHoleValVar"; } + + std::string toDBString() const; }; class ConstFPValVar : public ConstDataValVar @@ -1639,6 +1676,8 @@ class ConstFPValVar : public ConstDataValVar } virtual const std::string toString() const; + + std::string toDBString() const; }; class ConstIntValVar : public ConstDataValVar @@ -1705,6 +1744,8 @@ class ConstIntValVar : public ConstDataValVar } virtual const std::string toString() const; + + std::string toDBString() const; }; class ConstNullPtrValVar : public ConstDataValVar @@ -1759,6 +1800,8 @@ class ConstNullPtrValVar : public ConstDataValVar } virtual const std::string toString() const; + + std::string toDBString() const; }; class GlobalObjVar : public BaseObjVar @@ -1814,6 +1857,8 @@ class GlobalObjVar : public BaseObjVar virtual const std::string toString() const; + + std::string toDBString() const; }; class ConstAggObjVar : public BaseObjVar @@ -1874,6 +1919,7 @@ class ConstAggObjVar : public BaseObjVar } virtual const std::string toString() const; + std::string toDBString() const; }; class ConstDataObjVar : public BaseObjVar @@ -1937,6 +1983,9 @@ class ConstDataObjVar : public BaseObjVar } virtual const std::string toString() const; + + std::string getConstDataObjVarNodeFieldsStmt() const; + std::string toDBString() const; }; class ConstFPObjVar : public ConstDataObjVar @@ -2007,6 +2056,7 @@ class ConstFPObjVar : public ConstDataObjVar virtual const std::string toString() const; + std::string toDBString() const; }; class ConstIntObjVar : public ConstDataObjVar @@ -2083,6 +2133,7 @@ class ConstIntObjVar : public ConstDataObjVar virtual const std::string toString() const; + std::string toDBString() const; }; class ConstNullPtrObjVar : public ConstDataObjVar @@ -2143,6 +2194,8 @@ class ConstNullPtrObjVar : public ConstDataObjVar return false; } virtual const std::string toString() const; + + std::string toDBString() const; }; /* * Unique Return node of a procedure @@ -2204,6 +2257,8 @@ class RetValPN : public ValVar const std::string getValueName() const; virtual const std::string toString() const; + + std::string toDBString() const; }; /* @@ -2265,6 +2320,8 @@ class VarArgValPN : public ValVar return true; } virtual const std::string toString() const; + + std::string toDBString() const; }; /* @@ -2320,6 +2377,8 @@ class DummyValVar: public ValVar } virtual const std::string toString() const; + + std::string toDBString() const; }; /* @@ -2385,6 +2444,8 @@ class DummyObjVar: public BaseObjVar } virtual const std::string toString() const; + + std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/lib/Graphs/BasicBlockG.cpp b/svf/lib/Graphs/BasicBlockG.cpp index f82c49f23..8c5a63eb4 100644 --- a/svf/lib/Graphs/BasicBlockG.cpp +++ b/svf/lib/Graphs/BasicBlockG.cpp @@ -1,5 +1,6 @@ #include "Graphs/BasicBlockG.h" #include "Graphs/ICFGNode.h" +#include "SVFIR/GraphDBClient.h" using namespace SVF; const std::string BasicBlockEdge::toString() const @@ -22,3 +23,25 @@ const std::string SVFBasicBlock::toString() const rawstr << "\n----------------------------------------\n"; return rawstr.str(); } + +std::string SVFBasicBlock::toDBString() const +{ + const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(getId())+":" + std::to_string(getFunction()->getId()) + "'" + + ", fun_obj_var_id: " + std::to_string(getFunction()->getId()) + + ", bb_name:'" + getName() +"'" + + ", sscc_bb_ids:'" + GraphDBClient::getInstance().extractNodesIds(getSuccBBs()) + "'" + + ", pred_bb_ids:'" + GraphDBClient::getInstance().extractNodesIds(getPredBBs()) + "'" + + ", all_icfg_nodes_ids:'" + GraphDBClient::getInstance().extractNodesIds(getICFGNodeList()) + "'" + + + "})"; + return queryStatement; +} + +std::string BasicBlockEdge::toDBString() const +{ + const std::string queryStatement = + "MATCH (n:SVFBasicBlock {id:'"+std::to_string(getSrcID())+":"+std::to_string(getSrcNode()->getFunction()->getId())+"'}), (m:SVFBasicBlock{id:'"+std::to_string(getDstID())+":"+std::to_string(getDstNode()->getFunction()->getId())+ + "'}) WHERE n.id = '" +std::to_string(getSrcID())+":" + std::to_string(getSrcNode()->getFunction()->getId())+ "'"+ + " AND m.id = '" +std::to_string(getDstID())+":" + std::to_string(getDstNode()->getFunction()->getId())+ "'"+ + " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; + return queryStatement; +} diff --git a/svf/lib/Graphs/ICFG.cpp b/svf/lib/Graphs/ICFG.cpp index f6a8f5bbe..534f3c77d 100644 --- a/svf/lib/Graphs/ICFG.cpp +++ b/svf/lib/Graphs/ICFG.cpp @@ -31,6 +31,7 @@ #include "Graphs/CallGraph.h" #include "SVFIR/SVFIR.h" #include +#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; @@ -46,6 +47,17 @@ FunEntryICFGNode::FunEntryICFGNode(NodeID id, const FunObjVar* f) : InterICFGNod } } +std::string FunEntryICFGNode::toDBString() const +{ + const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(getBB()->getId()) + + ", fp_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getFormalParms()) +"'})"; + return queryStatement; +} + FunExitICFGNode::FunExitICFGNode(NodeID id, const FunObjVar* f) : InterICFGNode(id, FunExitBlock), formalRet(nullptr) { @@ -57,6 +69,24 @@ FunExitICFGNode::FunExitICFGNode(NodeID id, const FunObjVar* f) } } +std::string FunExitICFGNode::toDBString() const +{ + std::string formalRetId = ""; + if (nullptr == getFormalRet()) + { + formalRetId = ",formal_ret_node_id:-1"; + } else { + formalRetId = ",formal_ret_node_id:" + std::to_string(getFormalRet()->getId()); + } + const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(getBB()->getId()) + + formalRetId + "})"; + return queryStatement; +} + const std::string ICFGNode::toString() const { std::string str; @@ -149,6 +179,59 @@ const std::string CallICFGNode::toString() const return rawstr.str(); } +std::string CallICFGNode::toDBString() const +{ + std::string fun_name_of_v_call = ""; + std::string vtab_ptr_node_id = ""; + std::string virtual_fun_idx = ""; + std::string is_vir_call_inst = isVirtualCall() ? "true" : "false"; + std::string virtualFunAppendix = ""; + if (isVirtualCall()) + { + fun_name_of_v_call = ", fun_name_of_v_call: '"+getFunNameOfVirtualCall()+"'"; + vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(getVtablePtr()->getId()); + virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(getFunIdxInVtable()); + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; + } + else + { + vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; + virtual_fun_idx = ", virtual_fun_idx:-1"; + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; + } + std::string called_fun_obj_var_id = ""; + if (getCalledFunction() != nullptr) + { + called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(getCalledFunction()->getId()); + } + else + { + called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; + } + std::string ret_icfg_node_id = ""; + if (getRetICFGNode() != nullptr) + { + ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(getRetICFGNode()->getId()); + } + else + { + ret_icfg_node_id = ", ret_icfg_node_id: -1"; + } + const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ret_icfg_node_id + + ", bb_id: " + std::to_string(getBB()->getId()) + + ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + + ", svf_type:'" + getType()->toString() + "'" + + ", ap_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getActualParms()) +"'" + + called_fun_obj_var_id + + ", is_vararg: " + (isVarArg() ? "true" : "false") + + ", is_vir_call_inst: " + (isVirtualCall() ? "true" : "false") + + virtualFunAppendix+"})"; + return queryStatement; +} + const std::string RetICFGNode::toString() const { std::string str; @@ -162,6 +245,26 @@ const std::string RetICFGNode::toString() const return rawstr.str(); } +std::string RetICFGNode::toDBString() const +{ + std::string actual_ret_node_id=""; + if (getActualRet() != nullptr) + { + actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(getActualRet()->getId()) ; + } else { + actual_ret_node_id = ", actual_ret_node_id: -1"; + } + const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + actual_ret_node_id+ + ", call_block_node_id: " + std::to_string(getCallICFGNode()->getId()) + + ", bb_id: " + std::to_string(getBB()->getId()) + + ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + + ", svf_type:'" + getType()->toString() + "'"+"})"; + return queryStatement; +} + const std::string ICFGEdge::toString() const { std::string str; @@ -182,6 +285,31 @@ const std::string IntraCFGEdge::toString() const return rawstr.str(); } +std::string IntraCFGEdge::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); + std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); + std::string condition = ""; + if (getCondition() != nullptr) + { + condition = + ", condition_var_id:" + std::to_string(getCondition()->getId()) + + ", branch_cond_val:" + std::to_string(getSuccessorCondValue()); + } + else + { + condition = ", condition_var_id:-1, branch_cond_val:-1"; + } + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + + " AND m.id = " + std::to_string(getDstNode()->getId()) + + " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(getEdgeKind()) + + condition + "}]->(m)"; + return queryStatement; +} + const std::string CallCFGEdge::toString() const { std::string str; @@ -191,6 +319,20 @@ const std::string CallCFGEdge::toString() const return rawstr.str(); } +std::string CallCFGEdge::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); + std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + + " AND m.id = " + std::to_string(getDstNode()->getId()) + + " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(getEdgeKind()) + + ", call_pe_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getCallPEs()) + "'}]->(m)"; + return queryStatement; +} + const std::string RetCFGEdge::toString() const { std::string str; @@ -200,6 +342,29 @@ const std::string RetCFGEdge::toString() const return rawstr.str(); } +std::string RetCFGEdge::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); + std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); + std::string ret_pe_id = ""; + if (getRetPE() != nullptr) + { + ret_pe_id = ", ret_pe_id:" + std::to_string(getRetPE()->getEdgeID()); + } + else + { + ret_pe_id = ", ret_pe_id:-1"; + } + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + + " AND m.id = " + std::to_string(getDstNode()->getId()) + + " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(getEdgeKind()) + + ret_pe_id + "}]->(m)"; + return queryStatement; +} + /// Return call ICFGNode at the callsite const CallICFGNode* RetCFGEdge::getCallSite() const { @@ -481,6 +646,31 @@ void ICFG::updateCallGraph(CallGraph* callgraph) } } +std::string IntraICFGNode::toDBString() const +{ + const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ", is_return: " + (isRetInst() ? "true" : "false") + + ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(getBB()->getId()) + "})"; + return queryStatement; +} + +std::string InterICFGNode::toDBString() const{ + const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'})"; + return queryStatement; +} + +std::string GlobalICFGNode::toDBString() const +{ + const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(getId()) + + ", kind: " + std::to_string(getNodeKind()) + + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'})"; + return queryStatement; +} /*! * GraphTraits specialization */ diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 462f66700..0764a6110 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -54,17 +54,17 @@ bool GraphDBClient::addICFGEdge2db(lgraph::RpcClient* connection, if (nullptr != connection) { std::string queryStatement; - if(SVFUtil::isa(edge)) + if(const IntraCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = getIntraCFGEdgeStmt(SVFUtil::cast(edge)); + queryStatement = cfgEdge->toDBString(); } - else if (SVFUtil::isa(edge)) + else if (const CallCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = getCallCFGEdgeStmt(SVFUtil::cast(edge)); + queryStatement = cfgEdge->toDBString(); } - else if (SVFUtil::isa(edge)) + else if (const RetCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = getRetCFGEdgeStmt(SVFUtil::cast(edge)); + queryStatement = cfgEdge->toDBString(); } else { @@ -96,29 +96,29 @@ bool GraphDBClient::addICFGNode2db(lgraph::RpcClient* connection, if (nullptr != connection) { std::string queryStatement; - if(SVFUtil::isa(node)) + if(const GlobalICFGNode* globalICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getGlobalICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = globalICFGNode->toDBString(); } - else if (SVFUtil::isa(node)) + else if (const IntraICFGNode* intraICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getIntraICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = intraICFGNode->toDBString(); } - else if (SVFUtil::isa(node)) + else if (const FunEntryICFGNode* funEntryICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getFunEntryICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = funEntryICFGNode->toDBString(); } - else if (SVFUtil::isa(node)) + else if (const FunExitICFGNode* funExitICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getFunExitICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = funExitICFGNode->toDBString(); } - else if (SVFUtil::isa(node)) + else if (const CallICFGNode* callICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getCallICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = callICFGNode->toDBString(); } - else if (SVFUtil::isa(node)) + else if (const RetICFGNode* retICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = getRetICFGNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = retICFGNode->toDBString(); } else { @@ -218,121 +218,6 @@ std::vector GraphDBClient::stringToIds(const std::string& str) return ids; } -std::string GraphDBClient::getGlobalICFGNodeInsertStmt(const GlobalICFGNode* node) { - const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + "})"; - return queryStatement; -} - -std::string GraphDBClient::getIntraICFGNodeInsertStmt(const IntraICFGNode* node) { - const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", is_return: " + (node->isRetInst() ? "true" : "false") + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", bb_id:" + std::to_string(node->getBB()->getId()) + "})"; - return queryStatement; -} - -std::string GraphDBClient::getInterICFGNodeInsertStmt(const InterICFGNode* node) { - const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + "})"; - return queryStatement; -} - -std::string GraphDBClient::getFunEntryICFGNodeInsertStmt(const FunEntryICFGNode* node) { - const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", bb_id:" + std::to_string(node->getBB()->getId()) + - ", fp_nodes:'" + extractNodesIds(node->getFormalParms()) +"'})"; - return queryStatement; -} - -std::string GraphDBClient::getFunExitICFGNodeInsertStmt(const FunExitICFGNode* node) { - std::string formalRetId = ""; - if (nullptr == node->getFormalRet()) - { - formalRetId = ",formal_ret_node_id:-1"; - } else { - formalRetId = ",formal_ret_node_id:" + std::to_string(node->getFormalRet()->getId()); - } - const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", bb_id:" + std::to_string(node->getBB()->getId()) + - formalRetId + "})"; - return queryStatement; -} - -std::string GraphDBClient::getCallICFGNodeInsertStmt(const CallICFGNode* node) { - std::string fun_name_of_v_call = ""; - std::string vtab_ptr_node_id = ""; - std::string virtual_fun_idx = ""; - std::string is_vir_call_inst = node->isVirtualCall() ? "true" : "false"; - std::string virtualFunAppendix = ""; - if (node->isVirtualCall()) - { - fun_name_of_v_call = ", fun_name_of_v_call: '"+node->getFunNameOfVirtualCall()+"'"; - vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(node->getVtablePtr()->getId()); - virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(node->getFunIdxInVtable()); - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; - } - else - { - vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; - virtual_fun_idx = ", virtual_fun_idx:-1"; - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; - } - std::string called_fun_obj_var_id = ""; - if (node->getCalledFunction() != nullptr) - { - called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(node->getCalledFunction()->getId()); - } - else - { - called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; - } - std::string ret_icfg_node_id = ""; - if (node->getRetICFGNode() != nullptr) - { - ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()); - } - else - { - ret_icfg_node_id = ", ret_icfg_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ret_icfg_node_id + - ", bb_id: " + std::to_string(node->getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + - ", svf_type:'" + node->getType()->toString() + "'" + - ", ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'" + - called_fun_obj_var_id + - ", is_vararg: " + (node->isVarArg() ? "true" : "false") + - ", is_vir_call_inst: " + (node->isVirtualCall() ? "true" : "false") + - virtualFunAppendix+"})"; - return queryStatement; -} - -std::string GraphDBClient::getRetICFGNodeInsertStmt(const RetICFGNode* node) { - std::string actual_ret_node_id=""; - if (node->getActualRet() != nullptr) - { - actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(node->getActualRet()->getId()) ; - } else { - actual_ret_node_id = ", actual_ret_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - actual_ret_node_id+ - ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + - ", bb_id: " + std::to_string(node->getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + - ", svf_type:'" + node->getType()->toString() + "'"+"})"; - return queryStatement; -} - std::string GraphDBClient::getICFGNodeKindString(const ICFGNode* node) { if(SVFUtil::isa(node)) @@ -370,60 +255,6 @@ std::string GraphDBClient::getICFGNodeKindString(const ICFGNode* node) } } -std::string GraphDBClient::getIntraCFGEdgeStmt(const IntraCFGEdge* edge) { - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - std::string condition = ""; - if (edge->getCondition() != nullptr) - { - condition = ", condition_var_id:"+ std::to_string(edge->getCondition()->getId()) + - ", branch_cond_val:" + std::to_string(edge->getSuccessorCondValue()); - } else { - condition = ", condition_var_id:-1, branch_cond_val:-1"; - } - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - condition + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::getCallCFGEdgeStmt(const CallCFGEdge* edge) { - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - ", call_pe_ids:'"+ extractEdgesIds(edge->getCallPEs()) + - "'}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::getRetCFGEdgeStmt(const RetCFGEdge* edge) { - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - std::string ret_pe_id =""; - if (edge->getRetPE() != nullptr) - { - ret_pe_id = ", ret_pe_id:"+ std::to_string(edge->getRetPE()->getEdgeID()); - } else { - ret_pe_id = ", ret_pe_id:-1"; - } - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - ret_pe_id+ - "}]->(m)"; - return queryStatement; -} - void GraphDBClient::insertCHG2db(const CHGraph* chg) { std::string chgNodePath = @@ -619,29 +450,29 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co for (const auto& ty : *types) { std::string queryStatement; - if (SVFUtil::isa(ty)) + if (const SVFPointerType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFPointerTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } - else if (SVFUtil::isa(ty)) + else if (const SVFIntegerType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFIntegerTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } - else if (SVFUtil::isa(ty)) + else if (const SVFFunctionType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFFunctionTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } - else if (SVFUtil::isa(ty)) + else if (const SVFStructType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFSturctTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } - else if (SVFUtil::isa(ty)) + else if (const SVFArrayType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFArrayTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } - else if (SVFUtil::isa(ty)) + else if (const SVFOtherType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = getSVFOtherTypeNodeInsertStmt(SVFUtil::cast(ty)); + queryStatement = svfType->toDBString(); } else { @@ -661,10 +492,10 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co } // load & insert each stinfo node to db - for(const auto& stInfo : *stInfos) + for(const StInfo* stInfo : *stInfos) { // insert stinfo node to db - std::string queryStatement = getStInfoNodeInsertStmt(stInfo); + std::string queryStatement = stInfo->toDBString(); // SVFUtil::outs()<<"StInfo Insert Query:"<CallCypher(result, queryStatement, dbname); @@ -678,101 +509,6 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co } -std::string GraphDBClient::getSVFPointerTypeNodeInsertStmt(const SVFPointerType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFPointerType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + "})"; - return queryStatement; -} - -std::string GraphDBClient::getSVFIntegerTypeNodeInsertStmt(const SVFIntegerType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFIntegerType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + - ", single_and_width:" + std::to_string(node->getSignAndWidth()) + "})"; - return queryStatement; -} - -std::string GraphDBClient::getSVFFunctionTypeNodeInsertStmt(const SVFFunctionType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFFunctionType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + - ", params_types_vec:'" + extractSVFTypes(node->getParamTypes()) + - "', ret_ty_node_name:'" + node->getReturnType()->toString() + "'})"; - return queryStatement; -} - -std::string GraphDBClient::getSVFSturctTypeNodeInsertStmt(const SVFStructType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFStructType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", stinfo_node_id:" + std::to_string(node->getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + - ", struct_name:'" + node->getName() + "'})"; - return queryStatement; -} - -std::string GraphDBClient::getSVFArrayTypeNodeInsertStmt(const SVFArrayType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFArrayType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", stinfo_node_id:" + std::to_string(node->getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + - ", num_of_element:" + std::to_string(node->getNumOfElement()) + - ", type_of_element_node_type_name:'" + node->getTypeOfElement()->toString() + "'})"; - return queryStatement; -} - -std::string GraphDBClient::getSVFOtherTypeNodeInsertStmt(const SVFOtherType* node) -{ - std::string is_single_val_ty = node->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFOtherType {type_name:'" + node->toString() + - "', svf_i8_type_name:'" + node->getSVFInt8Type()->toString() + - "', svf_ptr_type_name:'" + node->getSVFPtrType()->toString() + - "', kind:" + std::to_string(node->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(node->getByteSize()) + - ", repr:'" + node->getRepr() + "'})"; - return queryStatement; -} - -std::string GraphDBClient::getStInfoNodeInsertStmt(const StInfo* node) -{ - const std::string queryStatement ="CREATE (n:StInfo {id:" + std::to_string(node->getStinfoId()) + - ", fld_idx_vec:'" + extractIdxs(node->getFlattenedFieldIdxVec()) + - "', elem_idx_vec:'" + extractIdxs(node->getFlattenedElemIdxVec()) + - "', finfo_types:'" + extractSVFTypes(node->getFlattenFieldTypes()) + - "', flatten_element_types:'" + extractSVFTypes(node->getFlattenElementTypes()) + - "', fld_idx_2_type_map:'" + extractFldIdx2TypeMap(node->getFldIdx2TypeMap()) + - "', stride:" + std::to_string(node->getStride()) + - ", num_of_flatten_elements:" + std::to_string(node->getNumOfFlattenElements()) + - ", num_of_flatten_fields:" + std::to_string(node->getNumOfFlattenFields()) + "})"; - return queryStatement; -} - void GraphDBClient::insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph) { if (nullptr != connection) @@ -798,7 +534,7 @@ void GraphDBClient::insertBBEdge2db(lgraph::RpcClient* connection, const BasicBl { if (nullptr != connection) { - std::string queryStatement = getBBEdgeInsertStmt(edge); + std::string queryStatement = edge->toDBString(); // SVFUtil::outs()<<"BBEdge Insert Query:"<toDBString(); // SVFUtil::outs()<<"BBNode Insert Query:"<getId())+":" + std::to_string(node->getFunction()->getId()) + "'" + - ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + - ", bb_name:'" + node->getName() +"'" + - ", sscc_bb_ids:'" + extractNodesIds(node->getSuccBBs()) + "'" + - ", pred_bb_ids:'" + extractNodesIds(node->getPredBBs()) + "'" + - ", all_icfg_nodes_ids:'" + extractNodesIds(node->getICFGNodeList()) + "'" + - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getBBEdgeInsertStmt(const BasicBlockEdge* edge) -{ - const std::string queryStatement = - "MATCH (n:SVFBasicBlock {id:'"+std::to_string(edge->getSrcID())+":"+std::to_string(edge->getSrcNode()->getFunction()->getId())+"'}), (m:SVFBasicBlock{id:'"+std::to_string(edge->getDstID())+":"+std::to_string(edge->getDstNode()->getFunction()->getId())+ - "'}) WHERE n.id = '" +std::to_string(edge->getSrcID())+":" + std::to_string(edge->getSrcNode()->getFunction()->getId())+ "'"+ - " AND m.id = '" +std::to_string(edge->getDstID())+":" + std::to_string(edge->getDstNode()->getFunction()->getId())+ "'"+ - " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; - return queryStatement; -} - void GraphDBClient::insertPAG2db(const PAG* pag) { std::string pagNodePath = @@ -928,77 +642,77 @@ void GraphDBClient::insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStm std::string GraphDBClient::getPAGEdgeInsertStmt(const SVFStmt* edge) { std::string queryStatement = ""; - if(SVFUtil::isa(edge)) + if(const TDForkPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateTDForkPEEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const TDJoinPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateTDJoinPEEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const CallPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateCallPEEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const RetPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateRetPEEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const GepStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateGepStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const LoadStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateLoadStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const StoreStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateStoreStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const CopyStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateCopyStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const AddrStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateAddrStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const AssignStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateAssignStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const PhiStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generatePhiStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const SelectStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateSelectStmtEndgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const CmpStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateCmpStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const BinaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateBinaryOPStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const MultiOpndStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateMultiOpndStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const UnaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = genereateUnaryOPStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const BranchStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateBranchStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } - else if(SVFUtil::isa(edge)) + else if(const SVFStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = generateSVFStmtEdgeInsertStmt(SVFUtil::cast(edge)); + queryStatement = svfStmt->toDBString(); } else { @@ -1029,962 +743,122 @@ void GraphDBClient::insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar std::string GraphDBClient::getPAGNodeInsertStmt(const SVFVar* node) { std::string queryStatement = ""; - if(SVFUtil::isa(node)) + if(const ConstNullPtrValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstNullPtrValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstIntValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstIntValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstFPValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstFPValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const BlackHoleValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getBlackHoleValvarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstDataValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstDataValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const RetValPN* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getRetValPNNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const VarArgValPN* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getVarArgValPNNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const DummyValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getDummyValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstAggValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstAggValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const GlobalValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getGlobalValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const FunValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getFunValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const GepValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getGepValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ArgValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getArgValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getValVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstNullPtrObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstNullPtrObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstIntObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstIntObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement =svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstFPObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstFPObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstDataObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstDataObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const DummyObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getDummyObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const ConstAggObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getConstAggObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const GlobalObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = getGlobalObjVarNodeInsertStmt(SVFUtil::cast(node)); + queryStatement = svfVar->toDBString(); } - else if(SVFUtil::isa(node)) + else if(const FunObjVar* svfVar = SVFUtil::dyn_cast(node)) { - const FunObjVar* funObjVar = SVFUtil::cast(node); - queryStatement = getFunObjVarNodeInsertStmt(funObjVar); - if ( nullptr != funObjVar->getBasicBlockGraph()) + queryStatement = svfVar->toDBString(); + if ( nullptr != svfVar->getBasicBlockGraph()) { - insertBasicBlockGraph2db(funObjVar->getBasicBlockGraph()); + insertBasicBlockGraph2db(svfVar->getBasicBlockGraph()); } } - else if(SVFUtil::isa(node)) - { - queryStatement = getStackObjVarNodeInsertStmt(SVFUtil::cast(node)); - } - else if(SVFUtil::isa(node)) - { - queryStatement = getHeapObjVarNodeInsertStmt(SVFUtil::cast(node)); - } - else if(SVFUtil::isa(node)) - { - queryStatement = getBaseObjNodeInsertStmt(SVFUtil::cast(node)); - } - else if(SVFUtil::isa(node)) - { - queryStatement = getGepObjVarNodeInsertStmt(SVFUtil::cast(node)); - } - else if(SVFUtil::isa(node)) - { - queryStatement = getObjVarNodeInsertStmt(SVFUtil::cast(node)); - } - else - { - assert("unknown SVFVar type?"); - } - return queryStatement; -} - -std::string GraphDBClient::getSVFVarNodeFieldsStmt(const SVFVar* node) -{ - std::string fieldsStr = ""; - fieldsStr += "id: " + std::to_string(node->getId()) + - ", svf_type_name:'"+node->getType()->toString() + - "', in_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(node->getInEdgeKindToSetMap()) + - "', out_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(node->getOutEdgeKindToSetMap()) + - "'"; - return fieldsStr; -} - -std::string GraphDBClient::getValVarNodeFieldsStmt(const ValVar* node) -{ - std::string fieldsStr = getSVFVarNodeFieldsStmt(node); - if ( nullptr != node->getICFGNode()) - { - fieldsStr += ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); - } - else - { - fieldsStr += ", icfg_node_id:-1"; - } - return fieldsStr; -} - -std::string GraphDBClient::getValVarNodeInsertStmt(const ValVar* node) -{ - const std::string queryStatement ="CREATE (n:ValVar {"+ - getValVarNodeFieldsStmt(node)+ - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstDataValVarNodeFieldsStmt(const ConstDataValVar* node) -{ - return getValVarNodeFieldsStmt(node); -} - - -std::string GraphDBClient::getConstDataValVarNodeInsertStmt(const ConstDataValVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ - getConstDataValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getBlackHoleValvarNodeInsertStmt(const BlackHoleValVar* node) -{ - const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ - getConstDataValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstFPValVarNodeInsertStmt(const ConstFPValVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ - getConstDataValVarNodeFieldsStmt(node) - +", kind:" + std::to_string(node->getNodeKind()) - +", dval:"+ std::to_string(node->getFPValue()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstIntValVarNodeInsertStmt(const ConstIntValVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ - getConstDataValVarNodeFieldsStmt(node) - +", kind:" + std::to_string(node->getNodeKind()) - +", zval:'"+ std::to_string(node->getZExtValue()) + "'" - +", sval:"+ std::to_string(node->getSExtValue()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstNullPtrValVarNodeInsertStmt(const ConstNullPtrValVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ - getConstDataValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getRetValPNNodeInsertStmt(const RetValPN* node) -{ - const std::string queryStatement ="CREATE (n:RetValPN {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - +", call_graph_node_id:"+std::to_string(node->getCallGraphNode()->getId()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getVarArgValPNNodeInsertStmt(const VarArgValPN* node) -{ - const std::string queryStatement ="CREATE (n:VarArgValPN {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - +", call_graph_node_id:"+std::to_string(node->getFunction()->getId()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getDummyValVarNodeInsertStmt(const DummyValVar* node) -{ - const std::string queryStatement ="CREATE (n:DummyValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstAggValVarNodeInsertStmt(const ConstAggValVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getGlobalValVarNodeInsertStmt(const GlobalValVar* node) -{ - const std::string queryStatement ="CREATE (n:GlobalValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getFunValVarNodeInsertStmt(const FunValVar* node) -{ - const std::string queryStatement ="CREATE (n:FunValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", fun_obj_var_node_id:" + std::to_string(node->getFunction()->getId()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getGepValVarNodeInsertStmt(const GepValVar* node) -{std::ostringstream accessPathFieldsStr; - accessPathFieldsStr << ""; - - if (nullptr != node->getAccessPath().gepSrcPointeeType()) - { - accessPathFieldsStr << ", ap_gep_pointee_type_name:'"<getAccessPath().gepSrcPointeeType()->toString()<<"'"; - } - if (!node->getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< IdxOperandPairsToString(&node->getAccessPath().getIdxOperandPairVec())<<"'"; - } - const std::string queryStatement ="CREATE (n:GepValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", base_val_id:" + std::to_string(node->getBaseNode()->getId()) - + ", gep_val_svf_type_name:'"+node->getType()->toString()+"'" - + ", ap_fld_idx:"+std::to_string(node->getConstantFieldIdx()) - + accessPathFieldsStr.str() - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getArgValVarNodeInsertStmt(const ArgValVar* node) -{ - const std::string queryStatement ="CREATE (n:ArgValVar {"+ - getValVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", cg_node_id:" + std::to_string(node->getParent()->getId()) - + ", arg_no:" + std::to_string(node->getArgNo()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getObjVarNodeFieldsStmt(const ObjVar* node) -{ - return getSVFVarNodeFieldsStmt(node); -} - -std::string GraphDBClient::getObjVarNodeInsertStmt(const ObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ObjVar {"+ - getObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getBaseObjVarNodeFieldsStmt(const BaseObjVar* node) -{ - std::string fieldsStr; - std::string icfgIDstr = ""; - if ( nullptr != node->getICFGNode()) - { - icfgIDstr = ", icfg_node_id:" + std::to_string(node->getICFGNode()->getId()); - } - else - { - icfgIDstr = ", icfg_node_id:-1"; - } - std::string objTypeInfo_byteSize_str = ""; - if (node->isConstantByteSize()) - { - objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + std::to_string(node->getByteSizeOfObj()); - } - fieldsStr += getObjVarNodeFieldsStmt(node) + - icfgIDstr + - ", obj_type_info_type_name:'" + node->getTypeInfo()->getType()->toString() + "'" + - ", obj_type_info_flags:" + std::to_string(node->getTypeInfo()->getFlag()) + - ", obj_type_info_max_offset_limit:" + std::to_string(node->getMaxFieldOffsetLimit()) + - ", obj_type_info_elem_num:" + std::to_string(node->getNumOfElements()) + - objTypeInfo_byteSize_str; - return fieldsStr; -} - -std::string GraphDBClient::getBaseObjNodeInsertStmt(const BaseObjVar* node) -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getGepObjVarNodeInsertStmt(const GepObjVar* node) -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", base_obj_var_node_id:" + std::to_string(node->getBaseObj()->getId()) - + ", app_offset:" + std::to_string(node->getConstantFieldIdx()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getHeapObjVarNodeInsertStmt(const HeapObjVar* node) -{ - const std::string queryStatement ="CREATE (n:HeapObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getStackObjVarNodeInsertStmt(const StackObjVar* node) -{ - const std::string queryStatement ="CREATE (n:StackObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* node) -{ - return getBaseObjVarNodeFieldsStmt(node); -} - -std::string GraphDBClient::getConstDataObjVarNodeInsertStmt(const ConstDataObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ - getConstDataObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstNullPtrObjVarNodeInsertStmt(const ConstNullPtrObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ - getConstDataObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstIntObjVarNodeInsertStmt(const ConstIntObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ - getConstDataObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", zval:'" + std::to_string(node->getZExtValue()) + "'" - + ", sval:" + std::to_string(node->getSExtValue()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstFPObjVarNodeInsertStmt(const ConstFPObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ - getConstDataObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", dval:" + std::to_string(node->getFPValue()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getDummyObjVarNodeInsertStmt(const DummyObjVar* node) -{ - const std::string queryStatement ="CREATE (n:DummyObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getConstAggObjVarNodeInsertStmt(const ConstAggObjVar* node) -{ - const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getGlobalObjVarNodeInsertStmt(const GlobalObjVar* node) -{ - const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getFunObjVarNodeInsertStmt(const FunObjVar* node) -{ - /// TODO: add bbGraph to bbGraph_tuGraph DB - std::ostringstream exitBBStr; - if (node->hasBasicBlock() && nullptr != node->getExitBB()) - { - exitBBStr << ", exit_bb_id:" << std::to_string(node->getExitBB()->getId()); - } - else - { - exitBBStr << ", exit_bb_id:-1"; - } - const std::string queryStatement ="CREATE (n:FunObjVar {"+ - getBaseObjVarNodeFieldsStmt(node) - + ", kind:" + std::to_string(node->getNodeKind()) - + ", is_decl:" + (node->isDeclaration()? "true" : "false") - + ", intrinsic:" + (node->isIntrinsic()? "true" : "false") - + ", is_addr_taken:" + (node->hasAddressTaken()? "true" : "false") - + ", is_uncalled:" + (node->isUncalledFunction()? "true" : "false") - + ", is_not_ret:" + (node->hasReturn()? "true" : "false") - + ", sup_var_arg:" + (node->isVarArg()? "true" : "false") - + ", fun_type_name:'" + node->getFunctionType()->toString() + "'" - + ", real_def_fun_node_id:" + std::to_string(node->getDefFunForMultipleModule()->getId()) - // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) - + exitBBStr.str() - + ", all_args_node_ids:'" + extractNodesIds(node->getArgs()) + "'" - + ", reachable_bbs:'" + extractNodesIds(node->getReachableBBs()) + "'" - + ", dt_bbs_map:'" + extractBBsMapWithSet2String(&(node->getDomTreeMap())) + "'" - + ", pdt_bbs_map:'" + extractBBsMapWithSet2String(&(node->getLoopAndDomInfo()->getPostDomTreeMap())) + "'" - + ", df_bbs_map:'" + extractBBsMapWithSet2String(&(node->getDomFrontierMap())) + "'" - + ", bb2_loop_map:'" + extractBBsMapWithSet2String(&(node->getLoopAndDomInfo()->getBB2LoopMap())) + "'" - + ", bb2_p_dom_level:'" + extractLabelMap2String(&(node->getLoopAndDomInfo()->getBBPDomLevel())) + "'" - + ", bb2_pi_dom:'" + extractBBsMap2String(&(node->getLoopAndDomInfo()->getBB2PIdom())) + "'" - + "})"; - return queryStatement; -} - -std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* edge) -{ - std::string valueStr = ""; - if (nullptr != edge->getValue()) - { - valueStr += ", svf_var_node_id:"+ std::to_string(edge->getValue()->getId()); - } - else - { - valueStr += ", svf_var_node_id:-1"; - } - std::string bb_id_str = ""; - if (nullptr != edge->getBB()) - { - bb_id_str += ", bb_id:'" + std::to_string(edge->getBB()->getParent()->getId()) + ":" + std::to_string(edge->getBB()->getId())+"'"; - } - else - { - bb_id_str += ", bb_id:''"; - } - - std::string icfg_node_id_str = ""; - if (nullptr != edge->getICFGNode()) - { - icfg_node_id_str += ", icfg_node_id:" + std::to_string(edge->getICFGNode()->getId()); - } - else - { - icfg_node_id_str += ", icfg_node_id:-1"; - } - - std::string inst2_label_map = ""; - if (nullptr != edge->getInst2LabelMap() && !edge->getInst2LabelMap()->empty()) - { - inst2_label_map += ", inst2_label_map:'"+ extractLabelMap2String(edge->getInst2LabelMap()) +"'"; - } - - std::string var2_label_map = ""; - if (nullptr != edge->getVar2LabelMap() && !edge->getVar2LabelMap()->empty()) - { - var2_label_map += ", var2_label_map:'"+ extractLabelMap2String(edge->getVar2LabelMap()) +"'"; - } - std::string fieldsStr = ""; - fieldsStr += "edge_id: " + std::to_string(edge->getEdgeID()) + - valueStr + - bb_id_str + - icfg_node_id_str + - inst2_label_map + - var2_label_map + - ", call_edge_label_counter:" + std::to_string(*(edge->getCallEdgeLabelCounter())) + - ", store_edge_label_counter:" + std::to_string(*(edge->getStoreEdgeLabelCounter())) + - ", multi_opnd_label_counter:" + std::to_string(*(edge->getMultiOpndLabelCounter())) + - ", edge_flag:" + std::to_string(edge->getEdgeKindWithoutMask()); - return fieldsStr; -} - -std::string GraphDBClient::generateSVFStmtEdgeInsertStmt(const SVFStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getSrcNode()); - std::string dstKind = getPAGNodeKindString(edge->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:SVFStmt{"+ - generateSVFStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateAssignStmtFieldsStmt(const AssignStmt* edge) -{ - return generateSVFStmtEdgeFieldsStmt(edge); -} - -std::string GraphDBClient::generateAssignStmtEdgeInsertStmt(const AssignStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:AssignStmt{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateAddrStmtEdgeInsertStmt(const AddrStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:AddrStmt{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", arr_size:'" + extractNodesIds(edge->getArrSize()) +"'"+ - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateCopyStmtEdgeInsertStmt(const CopyStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:CopyStmt{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", copy_kind:" + std::to_string(edge->getCopyKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateStoreStmtEdgeInsertStmt(const StoreStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:StoreStmt{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateLoadStmtEdgeInsertStmt(const LoadStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:LoadStmt{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateGepStmtEdgeInsertStmt(const GepStmt* edge) -{ - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - std::ostringstream accessPathStr; - accessPathStr << ""; - if (!edge->isVariantFieldGep()) - { - accessPathStr << ", ap_fld_idx:" - << std::to_string(edge->getConstantStructFldIdx()); - } - else - { - accessPathStr << ", ap_fld_idx:-1"; - } - - if (nullptr != edge->getAccessPath().gepSrcPointeeType()) - { - accessPathStr << ", ap_gep_pointee_type_name:'" - << edge->getAccessPath().gepSrcPointeeType()->toString() - << "'"; - } - if (!edge->getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathStr << ", ap_idx_operand_pairs:'" - << IdxOperandPairsToString( - &edge->getAccessPath().getIdxOperandPairVec()) - << "'"; - } - - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - accessPathStr.str() + - ", variant_field:" + (edge->isVariantFieldGep()? "true" : "false") + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateCallPEEdgeInsertStmt(const CallPE* edge) -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != edge->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != edge->getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:CallPE{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateRetPEEdgeInsertStmt(const RetPE* edge) -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != edge->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != edge->getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:RetPE{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateTDForkPEEdgeInsertStmt(const TDForkPE* edge) -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != edge->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != edge->getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(edge->getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:TDForkPE{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateTDJoinPEEdgeInsertStmt(const TDJoinPE* edge) -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != edge->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(edge->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != edge->getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(edge->getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(edge->getRHSVar()); - std::string dstKind = getPAGNodeKindString(edge->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(edge->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(edge->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(edge->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(edge->getLHSVar()->getId()) + - " CREATE (n)-[r:TDJoinPE{"+ - generateAssignStmtFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* edge) -{ - std::string stmt = generateSVFStmtEdgeFieldsStmt(edge); - if (! edge->getOpndVars().empty()) - { - stmt += ", op_var_node_ids:'" + extractNodesIds(edge->getOpndVars())+"'"; - } - else - { - stmt += ", op_var_node_ids:''"; - } - return stmt; -} - -std::string GraphDBClient::generateMultiOpndStmtEdgeInsertStmt(const MultiOpndStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:MultiOpndStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generatePhiStmtEdgeInsertStmt(const PhiStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:PhiStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", op_icfg_nodes_ids:'" + extractNodesIds(*(edge->getOpICFGNodeVec())) + "'"+ - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateSelectStmtEndgeInsertStmt(const SelectStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:SelectStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", condition_svf_var_node_id:" + std::to_string(edge->getCondition()->getId()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateCmpStmtEdgeInsertStmt(const CmpStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:CmpStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", predicate:" + std::to_string(edge->getPredicate()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateBinaryOPStmtEdgeInsertStmt(const BinaryOPStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:BinaryOPStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", op_code:" + std::to_string(edge->getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::genereateUnaryOPStmtEdgeInsertStmt(const UnaryOPStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:UnaryOPStmt{"+ - generateSVFStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", op_code:" + std::to_string(edge->getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -std::string GraphDBClient::generateBranchStmtEdgeInsertStmt(const BranchStmt* edge) -{ - const SVFStmt* stmt = SVFUtil::cast(edge); - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:BranchStmt{"+ - generateSVFStmtEdgeFieldsStmt(edge) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", successors:'" + extractSuccessorsPairSet2String(&(edge->getSuccessors())) + "'"+ - ", condition_svf_var_node_id:" + std::to_string(edge->getCondition()->getId()) + - ", br_inst_svf_var_node_id:" + std::to_string(edge->getBranchInst()->getId()) + - "}]->(m)"; + else if(const StackObjVar* svfVar = SVFUtil::dyn_cast(node)) + { + queryStatement = svfVar->toDBString(); + } + else if(const HeapObjVar* svfVar = SVFUtil::dyn_cast(node)) + { + queryStatement = svfVar->toDBString(); + } + else if(const BaseObjVar* svfVar = SVFUtil::dyn_cast(node)) + { + queryStatement = svfVar->toDBString(); + } + else if(const GepObjVar* svfVar = SVFUtil::dyn_cast(node)) + { + queryStatement = svfVar->toDBString(); + } + else if(const ObjVar* svfVar = SVFUtil::dyn_cast(node)) + { + queryStatement = svfVar->toDBString(); + } + else + { + assert("unknown SVFVar type?"); + } return queryStatement; } @@ -2593,26 +1467,26 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } } } - pag->addAddrStmt(addrStmt); + pag->addAddrStmtFromDB(addrStmt); } else if (edgeType == "CopyStmt") { int copy_kind = cJSON_GetObjectItem(properties,"copy_kind")->valueint; stmt = new CopyStmt(srcNode, dstNode, edgeFlag, edge_id, value, copy_kind, icfgNode ); CopyStmt* copyStmt = SVFUtil::cast(stmt); - pag->addCopyStmt(copyStmt); + pag->addCopyStmtFromDB(copyStmt); } else if (edgeType == "StoreStmt") { stmt = new StoreStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); StoreStmt* storeStmt = SVFUtil::cast(stmt); - pag->addStoreStmt(storeStmt, srcNode, dstNode); + pag->addStoreStmtFromDB(storeStmt, srcNode, dstNode); } else if (edgeType == "LoadStmt") { stmt = new LoadStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); LoadStmt* loadStmt = SVFUtil::cast(stmt); - pag->addLoadStmt(loadStmt); + pag->addLoadStmtFromDB(loadStmt); } else if (edgeType == "GepStmt") { @@ -2654,7 +1528,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: stmt = new GepStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, *ap, variant_field); GepStmt* gepStmt = SVFUtil::cast(stmt); - pag->addGepStmt(gepStmt); + pag->addGepStmtFromDB(gepStmt); } else if (edgeType == "CallPE") { @@ -2682,7 +1556,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } stmt = new CallPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); CallPE* callPE = SVFUtil::cast(stmt); - pag->addCallPE(callPE, srcNode, dstNode); + pag->addCallPEFromDB(callPE, srcNode, dstNode); id2CallPEMap[edge_id] = callPE; } else if (edgeType == "TDForkPE") @@ -2711,7 +1585,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } stmt = new TDForkPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); TDForkPE* forkPE = SVFUtil::cast(stmt); - pag->addCallPE(forkPE, srcNode, dstNode); + pag->addCallPEFromDB(forkPE, srcNode, dstNode); id2CallPEMap[edge_id] = forkPE; } else if (edgeType == "RetPE") @@ -2740,7 +1614,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } stmt = new RetPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode,callICFGNode, funExitICFGNode); RetPE* retPE = SVFUtil::cast(stmt); - pag->addRetPE(retPE, srcNode, dstNode); + pag->addRetPEFromDB(retPE, srcNode, dstNode); id2RetPEMap[edge_id] = retPE; } else if (edgeType == "RetPETDJoinPE") @@ -2769,7 +1643,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } stmt = new TDJoinPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funExitICFGNode); TDJoinPE* joinPE = SVFUtil::cast(stmt); - pag->addRetPE(joinPE, srcNode, dstNode); + pag->addRetPEFromDB(joinPE, srcNode, dstNode); id2RetPEMap[edge_id] = joinPE; } else if (edgeType == "PhiStmt") @@ -2798,7 +1672,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } phiStmt->setOpICFGNodeVec(opICFGNodes); } - pag->addPhiStmt(phiStmt, srcNode, dstNode); + pag->addPhiStmtFromDB(phiStmt, srcNode, dstNode); } else if (edgeType == "SelectStmt") { @@ -2809,7 +1683,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: SVFVar* condition = pag->getGNode(condition_svf_var_node_id); stmt = new SelectStmt(srcNode, dstNode, edgeFlag, edge_id, condition, value, icfgNode, opVarNodes); SelectStmt* selectStmt = SVFUtil::cast(stmt); - pag->addSelectStmt(selectStmt, srcNode, dstNode); + pag->addSelectStmtFromDB(selectStmt, srcNode, dstNode); } else if (edgeType == "CmpStmt") { @@ -2819,7 +1693,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: u32_t predicate = cJSON_GetObjectItem(properties, "predicate")->valueint; stmt = new CmpStmt(srcNode, dstNode, edgeFlag, edge_id, value, predicate, icfgNode, opVarNodes); CmpStmt* cmpStmt = SVFUtil::cast(stmt); - pag->addCmpStmt(cmpStmt, srcNode, dstNode); + pag->addCmpStmtFromDB(cmpStmt, srcNode, dstNode); } else if (edgeType == "BinaryOPStmt") { @@ -2829,14 +1703,14 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; stmt = new BinaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode, opVarNodes); BinaryOPStmt* binaryOpStmt = SVFUtil::cast(stmt); - pag->addBinaryOPStmt(binaryOpStmt, srcNode, dstNode); + pag->addBinaryOPStmtFromDB(binaryOpStmt, srcNode, dstNode); } else if (edgeType == "UnaryOPStmt") { u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; stmt = new UnaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode); UnaryOPStmt* unaryOpStmt = SVFUtil::cast(stmt); - pag->addUnaryOPStmt(unaryOpStmt, srcNode, dstNode); + pag->addUnaryOPStmtFromDB(unaryOpStmt, srcNode, dstNode); } else if (edgeType == "BranchStmt") { @@ -2871,7 +1745,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } stmt = new BranchStmt(srcNode, dstNode, edgeFlag, edge_id, value, successors, condition, brInst, icfgNode); BranchStmt* branchStmt = SVFUtil::cast(stmt); - pag->addBranchStmt(branchStmt, srcNode, dstNode); + pag->addBranchStmtFromDB(branchStmt, srcNode, dstNode); } stmt->setBasicBlock(bb); stmt->setCallEdgeLabelCounter(static_cast(call_edge_label_counter)); @@ -3012,7 +1886,7 @@ void GraphDBClient::updateSVFValVarAtrributes(cJSON* properties, ValVar* var, SV ICFGNode* icfgNode = pag->getICFG()->getGNode(icfg_node_id); if (nullptr != icfgNode) { - var->updateSVFValVar(icfgNode); + var->updateSVFValVarFromDB(icfgNode); } else { @@ -3359,557 +2233,579 @@ void GraphDBClient::parseAPIdxOperandPairsString(const std::string& ap_idx_opera void GraphDBClient::updateSVFPAGNodesAttributesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) { - std::string result; - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) + int skip = 0; + int limit = 1000; + while (true) { - cJSON* node; - cJSON_ArrayForEach(node, root) + std::string result; + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+ std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - if (nodeType == "ConstNullPtrValVar") + break; + } + else + { + cJSON* node; + cJSON_ArrayForEach(node, root) { - ConstNullPtrValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrValVar found for id: " << id << "\n"; + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) continue; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + if (nodeType == "ConstNullPtrValVar") + { + ConstNullPtrValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstIntValVar") - { - ConstIntValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstIntValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntValVar found for id: " << id << "\n"; - continue; + ConstIntValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstFPValVar") - { - ConstFPValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstFPValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPValVar found for id: " << id << "\n"; - continue; + ConstFPValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ArgValVar") - { - ArgValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ArgValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ArgValVar found for id: " << id << "\n"; - continue; + ArgValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ArgValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int cg_node_id = cJSON_GetObjectItem(properties, "cg_node_id")->valueint; + FunObjVar* cgNode = id2funObjVarsMap[cg_node_id]; + if (nullptr != cgNode) + { + var->addCGNodeFromDB(cgNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << cg_node_id <<" when updating ArgValVar:"<< id << "\n"; + } } - updateSVFValVarAtrributes(properties, var, pag); - int cg_node_id = cJSON_GetObjectItem(properties, "cg_node_id")->valueint; - FunObjVar* cgNode = id2funObjVarsMap[cg_node_id]; - if (nullptr != cgNode) + else if (nodeType == "BlackHoleValVar") { - var->addCGNode(cgNode); + BlackHoleValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BlackHoleValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - else + else if (nodeType == "ConstDataValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << cg_node_id <<" when updating ArgValVar:"<< id << "\n"; + ConstDataValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - } - else if (nodeType == "BlackHoleValVar") - { - BlackHoleValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "RetValPN") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BlackHoleValVar found for id: " << id << "\n"; - continue; + RetValPN* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching RetValPN found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; + FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; + if (nullptr != callGraphNode) + { + var->setCallGraphNode(callGraphNode); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating RetValPN:"<(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "VarArgValPN") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataValVar found for id: " << id << "\n"; - continue; + VarArgValPN* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching VarArgValPN found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; + FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; + if (nullptr != callGraphNode) + { + var->setCallGraphNode(callGraphNode); + pag->varargFunObjSymMap[callGraphNode] = var->getId(); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating VarArgValPN:"<(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "DummyValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching RetValPN found for id: " << id << "\n"; - continue; + DummyValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; - FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; - if (nullptr != callGraphNode) + else if (nodeType == "ConstAggValVar") { - var->setCallGraphNode(callGraphNode); + ConstAggValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - else + else if (nodeType == "GlobalValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating RetValPN:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - } - else if (nodeType == "VarArgValPN") - { - VarArgValPN* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "FunValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching VarArgValPN found for id: " << id << "\n"; - continue; + FunValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + int fun_obj_var_node_id = cJSON_GetObjectItem(properties, "fun_obj_var_node_id")->valueint; + FunObjVar* funObjVar = id2funObjVarsMap[fun_obj_var_node_id]; + if (nullptr != funObjVar) + { + var->setFunction(funObjVar); + } + else + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << fun_obj_var_node_id <<" when updating FunValVar:"<valueint; - FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; - if (nullptr != callGraphNode) + else if (nodeType == "GepValVar") { - var->setCallGraphNode(callGraphNode); + GepValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GepValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); + updateGepValVarAttributes(properties, var, pag); + } - else + else if (nodeType == "ValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating VarArgValPN:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ValVar found for id: " << id << "\n"; + continue; + } + updateSVFValVarAtrributes(properties, var, pag); } - } - else if (nodeType == "DummyValVar") - { - DummyValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstNullPtrObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyValVar found for id: " << id << "\n"; - continue; + ConstNullPtrObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstAggValVar") - { - ConstAggValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstIntObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggValVar found for id: " << id << "\n"; - continue; + ConstIntObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "GlobalValVar") - { - GlobalValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstFPObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalValVar found for id: " << id << "\n"; - continue; + ConstFPObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "FunValVar") - { - FunValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstDataObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunValVar found for id: " << id << "\n"; - continue; + ConstDataObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - int fun_obj_var_node_id = cJSON_GetObjectItem(properties, "fun_obj_var_node_id")->valueint; - FunObjVar* funObjVar = id2funObjVarsMap[fun_obj_var_node_id]; - if (nullptr != funObjVar) + else if (nodeType == "DummyObjVar") { - var->setFunction(funObjVar); + DummyObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - else + else if (nodeType == "ConstAggObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << fun_obj_var_node_id <<" when updating FunValVar:"<(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - } - else if (nodeType == "GepValVar") - { - GepValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "GlobalObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GepValVar found for id: " << id << "\n"; - continue; + GlobalObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - updateGepValVarAttributes(properties, var, pag); - - } - else if (nodeType == "ValVar") - { - ValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "FunObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ValVar found for id: " << id << "\n"; - continue; + FunObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); + updateFunObjVarAttributes(properties, var, pag); } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstNullPtrObjVar") - { - ConstNullPtrObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "StackObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrObjVar found for id: " << id << "\n"; - continue; + StackObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching StackObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstIntObjVar") - { - ConstIntObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "HeapObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntObjVar found for id: " << id << "\n"; - continue; + HeapObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching HeapObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstFPObjVar") - { - ConstFPObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "BaseObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPObjVar found for id: " << id << "\n"; - continue; + BaseObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); + if (var == nullptr) + { + SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BaseObjVar found for id: " << id << "\n"; + continue; + } + updateSVFBaseObjVarAtrributes(properties, var, pag); } - updateSVFBaseObjVarAtrributes(properties, var, pag); + skip += 1; } - else if (nodeType == "ConstDataObjVar") + cJSON_Delete(root); + } + + } +} + + +void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) +{ + int skip = 0; + int limit = 1000; + while (true) + { + std::string result; + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) + { + break; + } + else + { + cJSON* node; + cJSON_ArrayForEach(node, root) { - ConstDataObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataObjVar found for id: " << id << "\n"; + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + int id = cJSON_GetObjectItem(properties,"id")->valueint; + std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type_name")->valuestring; + const SVFType* type = pag->getSVFType(svfTypeName); + if (type == nullptr) + { + SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching SVFType found for type: " << svfTypeName << "for PAGNode:"<(pag->getGNode(id)); - if (var == nullptr) + + if (nodeType == "ConstNullPtrValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyObjVar found for id: " << id << "\n"; - continue; + ConstNullPtrValVar* var = new ConstNullPtrValVar(id, type, ValVar::ConstNullptrValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstAggObjVar") - { - ConstAggObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstIntValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggObjVar found for id: " << id << "\n"; - continue; + u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); + s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; + ConstIntValVar* var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "GlobalObjVar") - { - GlobalObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstFPValVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalObjVar found for id: " << id << "\n"; - continue; + double dval = cJSON_GetObjectItem(properties, "dval")->valuedouble; + ConstFPValVar* var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "FunObjVar") - { - FunObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ArgValVar") + { + u32_t arg_no = static_cast(cJSON_GetObjectItem(properties, "arg_no")->valueint); + ArgValVar* var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "BlackHoleValVar") + { + BlackHoleValVar* var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstDataValVar") + { + ConstDataValVar* var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "RetValPN") + { + RetValPN* var = new RetValPN(id, type, ValVar::RetValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "VarArgValPN") + { + VarArgValPN* var = new VarArgValPN(id, type, ValVar::VarargValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "DummyValVar") + { + DummyValVar* var = new DummyValVar(id, type, ValVar::DummyValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstAggValVar") + { + ConstAggValVar* var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "GlobalValVar") + { + GlobalValVar* var = new GlobalValVar(id, type, ValVar::GlobalValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "FunValVar") + { + FunValVar* var = new FunValVar(id, type, ValVar::FunValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "GepValVar") + { + std::string gep_val_svf_type_name = cJSON_GetObjectItem(properties, "gep_val_svf_type_name")->valuestring; + const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_name); + GepValVar* var = new GepValVar(id, type, gepValType, ValVar::GepValNode); + pag->addInitValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ValVar") + { + ValVar* var = new ValVar(id, type, ValVar::ValNode); + pag->addValNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfValues(); + } + else if (nodeType == "ConstNullPtrObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstNullPtrObjVar* var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstIntObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); + s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; + ConstIntObjVar* var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstFPObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + float dval = (float)(cJSON_GetObjectItem(properties, "dval")->valuedouble); + ConstFPObjVar* var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ConstDataObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << id << "\n"; - continue; + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstDataObjVar* var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - updateFunObjVarAttributes(properties, var, pag); - } - else if (nodeType == "StackObjVar") - { - StackObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "DummyObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching StackObjVar found for id: " << id << "\n"; - continue; + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + DummyObjVar* var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); + pag->addDummyObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "HeapObjVar") - { - HeapObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "ConstAggObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching HeapObjVar found for id: " << id << "\n"; - continue; + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + ConstAggObjVar* var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "BaseObjVar") - { - BaseObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) + else if (nodeType == "GlobalObjVar") { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BaseObjVar found for id: " << id << "\n"; - continue; + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + GlobalObjVar* var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - } - cJSON_Delete(root); - } -} - - -void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) -{ - std::string result; - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON* node; - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type_name")->valuestring; - const SVFType* type = pag->getSVFType(svfTypeName); - if (type == nullptr) - { - SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching SVFType found for type: " << svfTypeName << "for PAGNode:"<addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstIntValVar") - { - u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); - s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - ConstIntValVar* var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstFPValVar") - { - double dval = cJSON_GetObjectItem(properties, "dval")->valuedouble; - ConstFPValVar* var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ArgValVar") - { - u32_t arg_no = static_cast(cJSON_GetObjectItem(properties, "arg_no")->valueint); - ArgValVar* var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "BlackHoleValVar") - { - BlackHoleValVar* var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstDataValVar") - { - ConstDataValVar* var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "RetValPN") - { - RetValPN* var = new RetValPN(id, type, ValVar::RetValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "VarArgValPN") - { - VarArgValPN* var = new VarArgValPN(id, type, ValVar::VarargValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "DummyValVar") - { - DummyValVar* var = new DummyValVar(id, type, ValVar::DummyValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstAggValVar") - { - ConstAggValVar* var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "GlobalValVar") - { - GlobalValVar* var = new GlobalValVar(id, type, ValVar::GlobalValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "FunValVar") - { - FunValVar* var = new FunValVar(id, type, ValVar::FunValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "GepValVar") - { - std::string gep_val_svf_type_name = cJSON_GetObjectItem(properties, "gep_val_svf_type_name")->valuestring; - const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_name); - GepValVar* var = new GepValVar(id, type, gepValType, ValVar::GepValNode); - pag->addInitValNode(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ValVar") - { - ValVar* var = new ValVar(id, type, ValVar::ValNode); - pag->addValNodeFromDB(var); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstNullPtrObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstNullPtrObjVar* var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstIntObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); - s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - ConstIntObjVar* var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstFPObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - float dval = (float)(cJSON_GetObjectItem(properties, "dval")->valuedouble); - ConstFPObjVar* var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstDataObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstDataObjVar* var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "DummyObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - DummyObjVar* var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); - pag->addDummyObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstAggObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstAggObjVar* var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "GlobalObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - GlobalObjVar* var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "FunObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - bool is_decl = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_decl")); - bool intrinsic = cJSON_IsTrue(cJSON_GetObjectItem(properties, "intrinsic")); - bool is_addr_taken = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_addr_taken")); - bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); - bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_return")); - bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); - std::string fun_type_name = cJSON_GetObjectItem(properties, "fun_type_name")->valuestring; - const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_name)); - FunObjVar* var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); - std::string all_args_node_ids = cJSON_GetObjectItem(properties, "all_args_node_ids")->valuestring; - if (!all_args_node_ids.empty()) + else if (nodeType == "FunObjVar") { - std::vector all_args_node_ids_vec = parseElements2Container>(all_args_node_ids); - for (int arg_id : all_args_node_ids_vec) + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + bool is_decl = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_decl")); + bool intrinsic = cJSON_IsTrue(cJSON_GetObjectItem(properties, "intrinsic")); + bool is_addr_taken = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_addr_taken")); + bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); + bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_return")); + bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); + std::string fun_type_name = cJSON_GetObjectItem(properties, "fun_type_name")->valuestring; + const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_name)); + FunObjVar* var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); + std::string all_args_node_ids = cJSON_GetObjectItem(properties, "all_args_node_ids")->valuestring; + if (!all_args_node_ids.empty()) { - ArgValVar* arg = SVFUtil::dyn_cast(pag->getGNode(arg_id)); - if (arg != nullptr) - { - var->addArgument(arg); - } - else + std::vector all_args_node_ids_vec = parseElements2Container>(all_args_node_ids); + for (int arg_id : all_args_node_ids_vec) { - SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching ArgValVar found for id: " << arg_id << "\n"; + ArgValVar* arg = SVFUtil::dyn_cast(pag->getGNode(arg_id)); + if (arg != nullptr) + { + var->addArgument(arg); + } + else + { + SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching ArgValVar found for id: " << arg_id << "\n"; + } } } + pag->addBaseObjNodeFromDB(var); + id2funObjVarsMap[id] = var; + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } - pag->addBaseObjNode(var); - id2funObjVarsMap[id] = var; - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "StackObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - StackObjVar* var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "HeapObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - HeapObjVar* var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "BaseObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - BaseObjVar* var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); - pag->addBaseObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "GepObjVar") - { - s64_t app_offset = cJSON_GetObjectItem(properties, "app_offset")->valueint; - int base_obj_var_node_id = cJSON_GetObjectItem(properties, "base_obj_var_node_id")->valueint; - const BaseObjVar* baseObj = pag->getBaseObject(base_obj_var_node_id); - GepObjVar* var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); - pag->addGepObjNode(var); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ObjVar") - { - ObjVar* var = new ObjVar(id, type, ObjVar::ObjNode); - pag->addObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + else if (nodeType == "StackObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + StackObjVar* var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "HeapObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + HeapObjVar* var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "BaseObjVar") + { + ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); + BaseObjVar* var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); + pag->addBaseObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "GepObjVar") + { + s64_t app_offset = cJSON_GetObjectItem(properties, "app_offset")->valueint; + int base_obj_var_node_id = cJSON_GetObjectItem(properties, "base_obj_var_node_id")->valueint; + const BaseObjVar* baseObj = pag->getBaseObject(base_obj_var_node_id); + GepObjVar* var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); + pag->addGepObjNodeFromDB(var); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + else if (nodeType == "ObjVar") + { + ObjVar* var = new ObjVar(id, type, ObjVar::ObjNode); + pag->addObjNodeFromDB(SVFUtil::cast(var)); + NodeIDAllocator::get()->increaseNumOfObjAndNodes(); + } + skip += 1; } + cJSON_Delete(root); } - cJSON_Delete(root); } } @@ -3945,9 +2841,9 @@ cJSON* GraphDBClient::queryFromDB(lgraph::RpcClient* connection, const std::stri return nullptr; } // TODO: need to fix: all graph should support pagination query not only the PAG - if (dbname == "PAG" && result=="[]") + if (dbname != "BasicBlockGraph" && result=="[]") { - // SVFUtil::outs() << "No data found for query: " << queryStatement << "\n"; + SVFUtil::outs() << "No data found for query: " << queryStatement << "\n"; cJSON_Delete(root); return nullptr; } @@ -3973,33 +2869,34 @@ void GraphDBClient::readBasicBlockGraphFromDB(lgraph::RpcClient* connection, con void GraphDBClient::readBasicBlockNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) { - NodeID id = funObjVar->getId(); - std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(id) +" RETURN node"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON* node; - BasicBlockGraph* bbGraph = new BasicBlockGraph(); - funObjVar->setBasicBlockGraph(bbGraph); - cJSON_ArrayForEach(node, root) + NodeID id = funObjVar->getId(); + std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(id) +" RETURN node "; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - std::string id = cJSON_GetObjectItem(properties, "id")->valuestring; - std::string bb_name = - cJSON_GetObjectItem(properties, "bb_name")->valuestring; - int bbId = parseBBId(id); - SVFBasicBlock* bb = new SVFBasicBlock(bbId, funObjVar); - bb->setName(bb_name); - bbGraph->addBasicBlock(bb); - basicBlocks.insert(bb); - } - cJSON_Delete(root); - } + cJSON* node; + BasicBlockGraph* bbGraph = new BasicBlockGraph(); + funObjVar->setBasicBlockGraph(bbGraph); + cJSON_ArrayForEach(node, root) + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + continue; + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + continue; + std::string id = cJSON_GetObjectItem(properties, "id")->valuestring; + std::string bb_name = + cJSON_GetObjectItem(properties, "bb_name")->valuestring; + int bbId = parseBBId(id); + SVFBasicBlock* bb = new SVFBasicBlock(bbId, funObjVar); + bb->setName(bb_name); + bbGraph->addBasicBlockFromDB(bb); + basicBlocks.insert(bb); + } + cJSON_Delete(root); + } + } void GraphDBClient::readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) @@ -4009,48 +2906,49 @@ void GraphDBClient::readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, con { for (auto& pair: *bbGraph) { - SVFBasicBlock* bb = pair.second; - std::string queryStatement = "MATCH (node{id:'"+std::to_string(bb->getId())+":"+std::to_string(bb->getFunction()->getId())+"'}) RETURN node.pred_bb_ids, node.sscc_bb_ids"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON* item; - cJSON_ArrayForEach(item, root) + SVFBasicBlock* bb = pair.second; + std::string queryStatement = "MATCH (node{id:'"+std::to_string(bb->getId())+":"+std::to_string(bb->getFunction()->getId())+"'}) RETURN node.pred_bb_ids, node.sscc_bb_ids "; + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr != root) { - if (!item) - continue; - std::string pred_bb_ids = cJSON_GetObjectItem(item, "node.pred_bb_ids")->valuestring; - std::string sscc_bb_ids = cJSON_GetObjectItem(item, "node.sscc_bb_ids")->valuestring; - if (!pred_bb_ids.empty()) + cJSON* item; + cJSON_ArrayForEach(item, root) { - std::vector predBBIds = parseElements2Container>(pred_bb_ids); - for (int predBBId : predBBIds) + if (!item) + continue; + std::string pred_bb_ids = cJSON_GetObjectItem(item, "node.pred_bb_ids")->valuestring; + std::string sscc_bb_ids = cJSON_GetObjectItem(item, "node.sscc_bb_ids")->valuestring; + if (!pred_bb_ids.empty()) { - - SVFBasicBlock* predBB = bbGraph->getGNode(predBBId); - if (nullptr != predBB) + std::vector predBBIds = parseElements2Container>(pred_bb_ids); + for (int predBBId : predBBIds) { - bb->addPredBasicBlock(predBB); + + SVFBasicBlock* predBB = bbGraph->getGNode(predBBId); + if (nullptr != predBB) + { + bb->addPredBasicBlock(predBB); + } + } - } - } - if (!sscc_bb_ids.empty()) - { - std::vector ssccBBIds = parseElements2Container>(sscc_bb_ids); - for (int ssccBBId : ssccBBIds) + if (!sscc_bb_ids.empty()) { - SVFBasicBlock* ssccBB = bbGraph->getGNode(ssccBBId); - if (nullptr != ssccBB) + std::vector ssccBBIds = parseElements2Container>(sscc_bb_ids); + for (int ssccBBId : ssccBBIds) { - bb->addSuccBasicBlock(ssccBB); + SVFBasicBlock* ssccBB = bbGraph->getGNode(ssccBBId); + if (nullptr != ssccBB) + { + bb->addSuccBasicBlock(ssccBB); + } + } - } } + cJSON_Delete(root); } - cJSON_Delete(root); - } + } } } @@ -4079,70 +2977,80 @@ ICFG* GraphDBClient::buildICFGFromDB(lgraph::RpcClient* connection, const std::s void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, ICFG* icfg, SVFIR* pag) { - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) + int skip = 0; + int limit = 1000; + while (true) { - cJSON* node; - cJSON_ArrayForEach(node, root) + std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) + { + break; + } + else { - ICFGNode* icfgNode = nullptr; - if (nodeType == "GlobalICFGNode") + cJSON* node; + cJSON_ArrayForEach(node, root) { - icfgNode = parseGlobalICFGNodeFromDBResult(node); - if (nullptr != icfgNode) + ICFGNode* icfgNode = nullptr; + if (nodeType == "GlobalICFGNode") { - icfg->addGlobalICFGNode(SVFUtil::cast(icfgNode)); + icfgNode = parseGlobalICFGNodeFromDBResult(node); + if (nullptr != icfgNode) + { + icfg->addGlobalICFGNodeFromDB(SVFUtil::cast(icfgNode)); + } } - } - else if (nodeType == "IntraICFGNode") - { - icfgNode = parseIntraICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) + else if (nodeType == "IntraICFGNode") + { + icfgNode = parseIntraICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addIntraICFGNodeFromDB(SVFUtil::cast(icfgNode)); + } + } + else if (nodeType == "FunEntryICFGNode") { - icfg->addIntraICFGNode(SVFUtil::cast(icfgNode)); + icfgNode = parseFunEntryICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addFunEntryICFGNodeFromDB(SVFUtil::cast(icfgNode)); + } } - } - else if (nodeType == "FunEntryICFGNode") - { - icfgNode = parseFunEntryICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) + else if (nodeType == "FunExitICFGNode") { - icfg->addFunEntryICFGNode(SVFUtil::cast(icfgNode)); + icfgNode = parseFunExitICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addFunExitICFGNodeFromDB(SVFUtil::cast(icfgNode)); + } } - } - else if (nodeType == "FunExitICFGNode") - { - icfgNode = parseFunExitICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) + else if (nodeType == "RetICFGNode") { - icfg->addFunExitICFGNode(SVFUtil::cast(icfgNode)); + icfgNode = parseRetICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addRetICFGNodeFromDB(SVFUtil::cast(icfgNode)); + id2RetICFGNodeMap[icfgNode->getId()] = SVFUtil::cast(icfgNode); + } } - } - else if (nodeType == "RetICFGNode") - { - icfgNode = parseRetICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) + else if (nodeType == "CallICFGNode") { - icfg->addRetICFGNode(SVFUtil::cast(icfgNode)); - id2RetICFGNodeMap[icfgNode->getId()] = SVFUtil::cast(icfgNode); + icfgNode = parseCallICFGNodeFromDBResult(node, pag); + if (nullptr != icfgNode) + { + icfg->addCallICFGNodeFromDB(SVFUtil::cast(icfgNode)); + } } - } - else if (nodeType == "CallICFGNode") - { - icfgNode = parseCallICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) + + if (nullptr == icfgNode) { - icfg->addCallICFGNode(SVFUtil::cast(icfgNode)); + SVFUtil::outs()<< "Failed to create "<< nodeType<< " from db query result\n"; } + skip += 1; } - - if (nullptr == icfgNode) - { - SVFUtil::outs()<< "Failed to create "<< nodeType<< " from db query result\n"; - } + cJSON_Delete(root); } - cJSON_Delete(root); } } @@ -4199,7 +3107,7 @@ ICFGNode* GraphDBClient::parseFunEntryICFGNodeFromDBResult(const cJSON* node, SV SVFVar* fpNode = pag->getGNode(fpNodeId); if (nullptr != fpNode) { - pag->addFunArgs(SVFUtil::cast(icfgNode), funObjVar, fpNode); + pag->addFunArgsFromDB(SVFUtil::cast(icfgNode), funObjVar, fpNode); } else { @@ -4256,7 +3164,7 @@ ICFGNode* GraphDBClient::parseFunExitICFGNodeFromDBResult(const cJSON* node, SVF SVFVar* formalRet = pag->getGNode(formal_ret_node_id); if (nullptr != formalRet) { - pag->addFunRet(SVFUtil::cast(icfgNode), funObjVar, formalRet); + pag->addFunRetFromDB(SVFUtil::cast(icfgNode), funObjVar, formalRet); } else { @@ -4507,7 +3415,7 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* if (retICFGNode != nullptr) { - retICFGNode->addCallBlockNode(icfgNode); + retICFGNode->addCallBlockNodeFromDB(icfgNode); } // add this ICFGNode to its BasicBlock @@ -4525,36 +3433,46 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* void GraphDBClient::readICFGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, ICFG* icfg, SVFIR* pag) { - std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) + int skip = 0; + int limit = 1000; + while (true) { - cJSON* edge; - cJSON_ArrayForEach(edge, root) + std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) { - ICFGEdge* icfgEdge = nullptr; - if (edgeType == "IntraCFGEdge") - { - icfgEdge = parseIntraCFGEdgeFromDBResult(edge, pag, icfg); - } - else if (edgeType == "CallCFGEdge") - { - icfgEdge = parseCallCFGEdgeFromDBResult(edge, pag, icfg); - } - else if (edgeType == "RetCFGEdge") - { - icfgEdge = parseRetCFGEdgeFromDBResult(edge, pag, icfg); - } - if (nullptr != icfgEdge) - { - icfg->addICFGEdge(icfgEdge); - } - else + break; + } + else + { + cJSON* edge; + cJSON_ArrayForEach(edge, root) { - SVFUtil::outs()<< "Failed to create "<< edgeType << " from db query result\n"; + ICFGEdge* icfgEdge = nullptr; + if (edgeType == "IntraCFGEdge") + { + icfgEdge = parseIntraCFGEdgeFromDBResult(edge, pag, icfg); + } + else if (edgeType == "CallCFGEdge") + { + icfgEdge = parseCallCFGEdgeFromDBResult(edge, pag, icfg); + } + else if (edgeType == "RetCFGEdge") + { + icfgEdge = parseRetCFGEdgeFromDBResult(edge, pag, icfg); + } + if (nullptr != icfgEdge) + { + icfg->addICFGEdge(icfgEdge); + } + else + { + SVFUtil::outs()<< "Failed to create "<< edgeType << " from db query result\n"; + } + skip += 1; } + cJSON_Delete(root); } - cJSON_Delete(root); } } @@ -4697,48 +3615,68 @@ CallGraph* GraphDBClient::buildCallGraphFromDB(lgraph::RpcClient* connection, co void GraphDBClient::readCallGraphNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, CallGraph* callGraph) { - std::string queryStatement = " MATCH (node:CallGraphNode) RETURN node"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) + int skip = 0; + int limit = 1000; + while (true) { - cJSON* node; - cJSON_ArrayForEach(node, root) + std::string queryStatement = " MATCH (node:CallGraphNode) RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) + { + break; + } + else { - CallGraphNode* cgNode = nullptr; - cgNode = parseCallGraphNodeFromDB(node); - if (nullptr != cgNode) + cJSON* node; + cJSON_ArrayForEach(node, root) { - callGraph->addCallGraphNodeFromDB(cgNode); + CallGraphNode* cgNode = nullptr; + cgNode = parseCallGraphNodeFromDB(node); + if (nullptr != cgNode) + { + callGraph->addCallGraphNodeFromDB(cgNode); + } + skip += 1; } + cJSON_Delete(root); } - cJSON_Delete(root); } } void GraphDBClient::readCallGraphEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag, CallGraph* callGraph) { - std::string queryStatement = "MATCH ()-[edge]->() RETURN edge"; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) + int skip = 0; + int limit = 1000; + while (true) { - cJSON* edge; - cJSON_ArrayForEach(edge, root) + std::string queryStatement = "MATCH ()-[edge]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); + cJSON* root = queryFromDB(connection, dbname, queryStatement); + if (nullptr == root) + { + break; + } + else { - CallGraphEdge* cgEdge = nullptr; - cgEdge = parseCallGraphEdgeFromDB(edge, pag, callGraph); - if (nullptr != cgEdge) + cJSON* edge; + cJSON_ArrayForEach(edge, root) { - if (cgEdge->isDirectCallEdge()) - { - callGraph->addDirectCallGraphEdge(cgEdge); - } - if (cgEdge->isIndirectCallEdge()) + CallGraphEdge* cgEdge = nullptr; + cgEdge = parseCallGraphEdgeFromDB(edge, pag, callGraph); + if (nullptr != cgEdge) { - callGraph->addIndirectCallGraphEdge(cgEdge); + if (cgEdge->isDirectCallEdge()) + { + callGraph->addDirectCallGraphEdgeFromDB(cgEdge); + } + if (cgEdge->isIndirectCallEdge()) + { + callGraph->addIndirectCallGraphEdgeFromDB(cgEdge); + } } + skip += 1; } + cJSON_Delete(root); } - cJSON_Delete(root); } } @@ -4816,7 +3754,7 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* for (int directCallId : direct_call_set_ids) { CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(directCallId)); - callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); + callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addDirectCallSite(node); pag->addCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); @@ -4831,7 +3769,7 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* { CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(indirectCallId)); callGraph->numOfResolvedIndCallEdge++; - callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); + callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addInDirectCallSite(node); pag->addCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); diff --git a/svf/lib/SVFIR/SVFIR.cpp b/svf/lib/SVFIR/SVFIR.cpp index 34abb0f24..abe170729 100644 --- a/svf/lib/SVFIR/SVFIR.cpp +++ b/svf/lib/SVFIR/SVFIR.cpp @@ -74,7 +74,7 @@ AddrStmt* SVFIR::addAddrStmt(NodeID src, NodeID dst) return addrPE; } } -void SVFIR::addAddrStmt(AddrStmt* edge) +void SVFIR::addAddrStmtFromDB(AddrStmt* edge) { if(!hasEdge(edge, SVFStmt::Addr)) { @@ -101,7 +101,7 @@ CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type) } } -void SVFIR::addCopyStmt(CopyStmt* edge) +void SVFIR::addCopyStmtFromDB(CopyStmt* edge) { if(!hasEdge(edge, SVFStmt::Copy)) { @@ -134,7 +134,7 @@ PhiStmt* SVFIR::addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred) } } -void SVFIR::addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addPhiStmtFromDB(PhiStmt* edge, SVFVar* src, SVFVar* dst) { SVFVar* opNode = src; SVFVar* resNode = dst; @@ -168,7 +168,7 @@ SelectStmt* SVFIR::addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond } } -void SVFIR::addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addSelectStmtFromDB(SelectStmt* edge, SVFVar* src, SVFVar* dst) { if (!hasEdge(edge, SVFStmt::Select)) { @@ -197,7 +197,7 @@ CmpStmt* SVFIR::addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predicate) } } -void SVFIR::addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addCmpStmtFromDB(CmpStmt* edge, SVFVar* src, SVFVar* dst) { if (!hasEdge(edge,SVFStmt::Cmp)) { @@ -227,7 +227,7 @@ BinaryOPStmt* SVFIR::addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t o } } -void SVFIR::addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addBinaryOPStmtFromDB(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst) { if (!hasEdge(edge, SVFStmt::BinaryOp)) { @@ -253,7 +253,7 @@ UnaryOPStmt* SVFIR::addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode) } } -void SVFIR::addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addUnaryOPStmtFromDB(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst) { if(!hasEdge(edge, SVFStmt::UnaryOp)) { @@ -280,7 +280,7 @@ BranchStmt* SVFIR::addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccA } } -void SVFIR::addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addBranchStmtFromDB(BranchStmt* edge, SVFVar* src, SVFVar* dst) { if(!hasEdge(edge, SVFStmt::Branch)) { @@ -307,7 +307,7 @@ LoadStmt* SVFIR::addLoadStmt(NodeID src, NodeID dst) } } -void SVFIR::addLoadStmt(LoadStmt* edge) +void SVFIR::addLoadStmtFromDB(LoadStmt* edge) { if(!hasEdge(edge, SVFStmt::Load)) { @@ -335,7 +335,7 @@ StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const ICFGNode* curVal) } } -void SVFIR::addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addStoreStmtFromDB(StoreStmt* edge, SVFVar* src, SVFVar* dst) { if(!hasEdge(edge,SVFStmt::Store)) { @@ -362,7 +362,7 @@ CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const F } } -void SVFIR::addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addCallPEFromDB(CallPE* edge, SVFVar* src, SVFVar* dst) { if(!hasEdge(edge, SVFStmt::Call)) { @@ -389,7 +389,7 @@ RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const Fun } } -void SVFIR::addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addRetPEFromDB(RetPE* edge, SVFVar* src, SVFVar* dst) { if(!hasEdge(edge, SVFStmt::Ret)) { @@ -485,7 +485,7 @@ GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap) } } -void SVFIR::addGepStmt(GepStmt* gepPE) +void SVFIR::addGepStmtFromDB(GepStmt* gepPE) { SVFVar* baseNode = gepPE->getRHSVar(); SVFVar* dstNode = gepPE->getLHSVar(); @@ -581,7 +581,7 @@ NodeID SVFIR::getGepObjVar(const BaseObjVar* baseObj, const APOffset& apOffset) } -void SVFIR::addGepObjNode(GepObjVar* gepObj) +void SVFIR::addGepObjNodeFromDB(GepObjVar* gepObj) { NodeID base = gepObj->getBaseNode(); APOffset apOffset = gepObj->getConstantFieldIdx(); diff --git a/svf/lib/SVFIR/SVFStatements.cpp b/svf/lib/SVFIR/SVFStatements.cpp index 486631c1b..4fcbe13f5 100644 --- a/svf/lib/SVFIR/SVFStatements.cpp +++ b/svf/lib/SVFIR/SVFStatements.cpp @@ -30,6 +30,7 @@ #include "SVFIR/SVFStatements.h" #include "SVFIR/SVFIR.h" #include "Util/Options.h" +#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; @@ -410,3 +411,463 @@ BinaryOPStmt::BinaryOPStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar { assert(opnds.size() == 2 && "BinaryOPStmt can only have two operands!"); } + +std::string SVFStmt::generateSVFStmtEdgeFieldsStmt() const +{ + std::string valueStr = ""; + if (nullptr != getValue()) + { + valueStr += ", svf_var_node_id:"+ std::to_string(getValue()->getId()); + } + else + { + valueStr += ", svf_var_node_id:-1"; + } + std::string bb_id_str = ""; + if (nullptr != getBB()) + { + bb_id_str += ", bb_id:'" + std::to_string(getBB()->getParent()->getId()) + ":" + std::to_string(getBB()->getId())+"'"; + } + else + { + bb_id_str += ", bb_id:''"; + } + + std::string icfg_node_id_str = ""; + if (nullptr != getICFGNode()) + { + icfg_node_id_str += ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); + } + else + { + icfg_node_id_str += ", icfg_node_id:-1"; + } + + std::string inst2_label_map = ""; + if (nullptr != getInst2LabelMap() && !getInst2LabelMap()->empty()) + { + inst2_label_map += ", inst2_label_map:'"+ GraphDBClient::getInstance().extractLabelMap2String(getInst2LabelMap()) +"'"; + } + + std::string var2_label_map = ""; + if (nullptr != getVar2LabelMap() && !getVar2LabelMap()->empty()) + { + var2_label_map += ", var2_label_map:'"+ GraphDBClient::getInstance().extractLabelMap2String(getVar2LabelMap()) +"'"; + } + std::string fieldsStr = ""; + fieldsStr += "edge_id: " + std::to_string(getEdgeID()) + + valueStr + + bb_id_str + + icfg_node_id_str + + inst2_label_map + + var2_label_map + + ", call_edge_label_counter:" + std::to_string(*(getCallEdgeLabelCounter())) + + ", store_edge_label_counter:" + std::to_string(*(getStoreEdgeLabelCounter())) + + ", multi_opnd_label_counter:" + std::to_string(*(getMultiOpndLabelCounter())) + + ", edge_flag:" + std::to_string(getEdgeKindWithoutMask()); + return fieldsStr; +} + +std::string SVFStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getSrcNode()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(getSrcNode()->getId()) + + " AND m.id = " + std::to_string(getDstNode()->getId()) + + " CREATE (n)-[r:SVFStmt{"+ + generateSVFStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string AddrStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:AddrStmt{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", arr_size:'" + GraphDBClient::getInstance().extractNodesIds(getArrSize()) +"'"+ + "}]->(m)"; + return queryStatement; +} + +std::string CopyStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:CopyStmt{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", copy_kind:" + std::to_string(getCopyKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string StoreStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:StoreStmt{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string LoadStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:LoadStmt{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string GepStmt::toDBString() const +{ + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + std::ostringstream accessPathStr; + accessPathStr << ""; + if (!isVariantFieldGep()) + { + accessPathStr << ", ap_fld_idx:" + << std::to_string(getConstantStructFldIdx()); + } + else + { + accessPathStr << ", ap_fld_idx:-1"; + } + + if (nullptr != getAccessPath().gepSrcPointeeType()) + { + accessPathStr << ", ap_gep_pointee_type_name:'" + << getAccessPath().gepSrcPointeeType()->toString() + << "'"; + } + if (!getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathStr << ", ap_idx_operand_pairs:'" + << GraphDBClient::getInstance().IdxOperandPairsToString( + &(getAccessPath().getIdxOperandPairVec())) + << "'"; + } + + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + accessPathStr.str() + + ", variant_field:" + (isVariantFieldGep()? "true" : "false") + + "}]->(m)"; + return queryStatement; +} + +std::string CallPE::toDBString() const +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(getFunEntryICFGNode()->getId()); + } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:CallPE{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string RetPE::toDBString() const +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(getFunExitICFGNode()->getId()); + } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:RetPE{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string TDForkPE::toDBString() const +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(getFunEntryICFGNode()->getId()); + } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:TDForkPE{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string TDJoinPE::toDBString() const +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(getFunExitICFGNode()->getId()); + } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } + std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:TDJoinPE{"+ + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +std::string MultiOpndStmt::generateMultiOpndStmtEdgeFieldsStmt() const +{ + std::string stmt = generateSVFStmtEdgeFieldsStmt(); + if (!getOpndVars().empty()) + { + stmt += ", op_var_node_ids:'" + GraphDBClient::getInstance().extractNodesIds(getOpndVars())+"'"; + } + else + { + stmt += ", op_var_node_ids:''"; + } + return stmt; +} + +std::string MultiOpndStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:MultiOpndStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +std::string PhiStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:PhiStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", op_icfg_nodes_ids:'" + GraphDBClient::getInstance().extractNodesIds(*(getOpICFGNodeVec())) + "'"+ + "}]->(m)"; + return queryStatement; +} + +std::string SelectStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:SelectStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", condition_svf_var_node_id:" + std::to_string(getCondition()->getId()) + + "}]->(m)"; + return queryStatement; +} + +std::string CmpStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:CmpStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", predicate:" + std::to_string(getPredicate()) + + "}]->(m)"; + return queryStatement; +} + +std::string BinaryOPStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:BinaryOPStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", op_code:" + std::to_string(getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +std::string UnaryOPStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:UnaryOPStmt{"+ + generateSVFStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", op_code:" + std::to_string(getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +std::string BranchStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:BranchStmt{"+ + generateSVFStmtEdgeFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + + ", successors:'" + GraphDBClient::getInstance().extractSuccessorsPairSet2String(&(getSuccessors())) + "'"+ + ", condition_svf_var_node_id:" + std::to_string(getCondition()->getId()) + + ", br_inst_svf_var_node_id:" + std::to_string(getBranchInst()->getId()) + + "}]->(m)"; + return queryStatement; +} + +std::string AssignStmt::toDBString() const +{ + const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); + const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(getRHSVar()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(getLHSVar()->getId()) + + "}) WHERE n.id = " + std::to_string(getRHSVar()->getId()) + + " AND m.id = " + std::to_string(getLHSVar()->getId()) + + " CREATE (n)-[r:AssignStmt{" + generateAssignStmtFieldsStmt() + + ", kind:" + std::to_string(getEdgeKind()) + "}]->(m)"; + return queryStatement; +} diff --git a/svf/lib/SVFIR/SVFVariables.cpp b/svf/lib/SVFIR/SVFVariables.cpp index d8a49f7fe..af52b4e0d 100644 --- a/svf/lib/SVFIR/SVFVariables.cpp +++ b/svf/lib/SVFIR/SVFVariables.cpp @@ -33,6 +33,7 @@ #include "Util/Options.h" #include "Util/SVFUtil.h" #include "Graphs/CallGraph.h" +#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; @@ -529,3 +530,368 @@ const std::string DummyObjVar::toString() const return rawstr.str(); } +std::string SVFVar::getSVFVarNodeFieldsStmt() const +{ + std::string fieldsStr = ""; + fieldsStr += "id: " + std::to_string(getId()) + + ", svf_type_name:'"+getType()->toString() + + "', in_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getInEdgeKindToSetMap()) + + "', out_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getOutEdgeKindToSetMap()) + + "'"; + return fieldsStr; +} + +std::string ValVar::getValVarNodeFieldsStmt() const +{ + std::string fieldsStr = getSVFVarNodeFieldsStmt(); + if ( nullptr != getICFGNode()) + { + fieldsStr += ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); + } + else + { + fieldsStr += ", icfg_node_id:-1"; + } + return fieldsStr; +} + +std::string ValVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ValVar {"+ + getValVarNodeFieldsStmt()+ + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstDataValVar::getConstDataValVarNodeFieldsStmt() const +{ + return ValVar::getValVarNodeFieldsStmt(); +} + +std::string ConstDataValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ + getConstDataValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string BlackHoleValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ + getConstDataValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstFPValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ + getConstDataValVarNodeFieldsStmt() + +", kind:" + std::to_string(getNodeKind()) + +", dval:"+ std::to_string(getFPValue()) + + "})"; + return queryStatement; +} + +std::string ConstIntValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ + getConstDataValVarNodeFieldsStmt() + +", kind:" + std::to_string(getNodeKind()) + +", zval:'"+ std::to_string(getZExtValue()) + "'" + +", sval:"+ std::to_string(getSExtValue()) + + "})"; + return queryStatement; +} + +std::string ConstNullPtrValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ + getConstDataValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string RetValPN::toDBString()const +{ + const std::string queryStatement ="CREATE (n:RetValPN {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + +", call_graph_node_id:"+std::to_string(getCallGraphNode()->getId()) + + "})"; + return queryStatement; +} + +std::string VarArgValPN::toDBString()const +{ + const std::string queryStatement ="CREATE (n:VarArgValPN {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + +", call_graph_node_id:"+std::to_string(getFunction()->getId()) + + "})"; + return queryStatement; +} + +std::string DummyValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:DummyValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstAggValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GlobalValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:GlobalValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string FunValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:FunValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", fun_obj_var_node_id:" + std::to_string(getFunction()->getId()) + + "})"; + return queryStatement; +} + +std::string GepValVar::toDBString()const +{ + std::ostringstream accessPathFieldsStr; + accessPathFieldsStr << ""; + + if (nullptr != getAccessPath().gepSrcPointeeType()) + { + accessPathFieldsStr << ", ap_gep_pointee_type_name:'"<toString()<<"'"; + } + if (!getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< GraphDBClient::getInstance().IdxOperandPairsToString(&(getAccessPath().getIdxOperandPairVec()))<<"'"; + } + const std::string queryStatement ="CREATE (n:GepValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", base_val_id:" + std::to_string(getBaseNode()->getId()) + + ", gep_val_svf_type_name:'"+getType()->toString()+"'" + + ", ap_fld_idx:"+std::to_string(getConstantFieldIdx()) + + accessPathFieldsStr.str() + + "})"; + return queryStatement; +} + +std::string ArgValVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ArgValVar {"+ + getValVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", cg_node_id:" + std::to_string(getParent()->getId()) + + ", arg_no:" + std::to_string(getArgNo()) + + "})"; + return queryStatement; +} + +std::string ObjVar::getObjVarNodeFieldsStmt() const +{ + return SVFVar::getSVFVarNodeFieldsStmt(); +} + +std::string ObjVar::toDBString()const +{ + const std::string queryStatement ="CREATE (n:ObjVar {"+ + getObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string BaseObjVar::getBaseObjVarNodeFieldsStmt() const +{ + std::string fieldsStr; + std::string icfgIDstr = ""; + if ( nullptr != getICFGNode()) + { + icfgIDstr = ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); + } + else + { + icfgIDstr = ", icfg_node_id:-1"; + } + std::string objTypeInfo_byteSize_str = ""; + if (isConstantByteSize()) + { + objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + std::to_string(getByteSizeOfObj()); + } + fieldsStr += getObjVarNodeFieldsStmt() + + icfgIDstr + + ", obj_type_info_type_name:'" + getTypeInfo()->getType()->toString() + "'" + + ", obj_type_info_flags:" + std::to_string(getTypeInfo()->getFlag()) + + ", obj_type_info_max_offset_limit:" + std::to_string(getMaxFieldOffsetLimit()) + + ", obj_type_info_elem_num:" + std::to_string(getNumOfElements()) + + objTypeInfo_byteSize_str; + return fieldsStr; +} + +std::string BaseObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GepObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", base_obj_var_node_id:" + std::to_string(getBaseObj()->getId()) + + ", app_offset:" + std::to_string(getConstantFieldIdx()) + + "})"; + return queryStatement; +} + +std::string HeapObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:HeapObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string StackObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:StackObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstDataObjVar::getConstDataObjVarNodeFieldsStmt() const +{ + return getBaseObjVarNodeFieldsStmt(); +} + +std::string ConstDataObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ + getConstDataObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstNullPtrObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ + getConstDataObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstIntObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ + getConstDataObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", zval:'" + std::to_string(getZExtValue()) + "'" + + ", sval:" + std::to_string(getSExtValue()) + + "})"; + return queryStatement; +} + +std::string ConstFPObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ + getConstDataObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", dval:" + std::to_string(getFPValue()) + + "})"; + return queryStatement; +} + +std::string DummyObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:DummyObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string ConstAggObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string GlobalObjVar::toDBString() const +{ + const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + "})"; + return queryStatement; +} + +std::string FunObjVar::toDBString() const +{ + std::ostringstream exitBBStr; + if (hasBasicBlock() && nullptr != getExitBB()) + { + exitBBStr << ", exit_bb_id:" << std::to_string(getExitBB()->getId()); + } + else + { + exitBBStr << ", exit_bb_id:-1"; + } + const std::string queryStatement ="CREATE (n:FunObjVar {"+ + getBaseObjVarNodeFieldsStmt() + + ", kind:" + std::to_string(getNodeKind()) + + ", is_decl:" + (isDeclaration()? "true" : "false") + + ", intrinsic:" + (isIntrinsic()? "true" : "false") + + ", is_addr_taken:" + (hasAddressTaken()? "true" : "false") + + ", is_uncalled:" + (isUncalledFunction()? "true" : "false") + + ", is_not_ret:" + (hasReturn()? "true" : "false") + + ", sup_var_arg:" + (isVarArg()? "true" : "false") + + ", fun_type_name:'" + getFunctionType()->toString() + "'" + + ", real_def_fun_node_id:" + std::to_string(getDefFunForMultipleModule()->getId()) + // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) + + exitBBStr.str() + + ", all_args_node_ids:'" + GraphDBClient::getInstance().extractNodesIds(getArgs()) + "'" + + ", reachable_bbs:'" + GraphDBClient::getInstance().extractNodesIds(getReachableBBs()) + "'" + + ", dt_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getDomTreeMap())) + "'" + + ", pdt_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getLoopAndDomInfo()->getPostDomTreeMap())) + "'" + + ", df_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getDomFrontierMap())) + "'" + + ", bb2_loop_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getLoopAndDomInfo()->getBB2LoopMap())) + "'" + + ", bb2_p_dom_level:'" + GraphDBClient::getInstance().extractLabelMap2String(&(getLoopAndDomInfo()->getBBPDomLevel())) + "'" + + ", bb2_pi_dom:'" + GraphDBClient::getInstance().extractBBsMap2String(&(getLoopAndDomInfo()->getBB2PIdom())) + "'" + + "})"; + return queryStatement; +} + From 3f0aebb10b41c901d39496ddb9486a87fdfcf7dc Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sun, 1 Jun 2025 23:37:19 +1000 Subject: [PATCH 04/19] add svfstmts for icfgNode --- svf/include/SVFIR/GraphDBClient.h | 10 +++-- svf/include/SVFIR/SVFVariables.h | 5 +++ svf/lib/SVFIR/GraphDBClient.cpp | 67 ++++++++++++++++++++++++++++++- svf/lib/SVFIR/SVFVariables.cpp | 2 +- 4 files changed, 78 insertions(+), 6 deletions(-) diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 52fc205eb..4296010bb 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -136,6 +136,7 @@ class GraphDBClient ICFGNode* parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); ICFGNode* parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); ICFGNode* parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); + void parseSVFStmtsForICFGNodeFromDBResult(SVFIR* pag); void updateRetPE4RetCFGEdge(); void updateCallPEs4CallCFGEdge(); @@ -256,7 +257,8 @@ class GraphDBClient if constexpr (std::is_same::value) { - if constexpr (std::is_same>::value) + if constexpr (std::is_same>::value || + std::is_same>::value) idxVec.push_back(std::stoi(token)); else idxVec.insert(std::stoi(token)); @@ -264,14 +266,16 @@ class GraphDBClient else if constexpr (std::is_same::value) { - if constexpr (std::is_same>::value) + if constexpr (std::is_same>::value || + std::is_same>::value) idxVec.push_back(static_cast(std::stoul(token))); else idxVec.insert(static_cast(std::stoul(token))); } else { - if constexpr (std::is_same>::value) + if constexpr (std::is_same>::value || + std::is_same>::value) idxVec.push_back(std::stof(token)); else idxVec.insert(std::stof(token)); diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index 64e334f50..db9cd2a3a 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -1173,6 +1173,11 @@ class FunObjVar : public BaseObjVar return !isNotRet; } + inline bool getIsNotRet() const + { + return isNotRet; + } + /// Returns the FunctionType inline const SVFFunctionType* getFunctionType() const { diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 0764a6110..e0c27251d 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -10,6 +10,8 @@ Map id2CallPEMap; Map id2RetPEMap; Map callCFGEdge2CallPEStrMap; Map retCFGEdge2RetPEStrMap; +Map icfgNode2StmtsStrMap; +Map edgeId2SVFStmtMap; bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, const std::string& filepath, @@ -1788,6 +1790,7 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: } } skip += 1; + edgeId2SVFStmtMap[stmt->getEdgeID()] = stmt; } cJSON_Delete(root); } @@ -2740,7 +2743,7 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: bool intrinsic = cJSON_IsTrue(cJSON_GetObjectItem(properties, "intrinsic")); bool is_addr_taken = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_addr_taken")); bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); - bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_return")); + bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_ret")); bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); std::string fun_type_name = cJSON_GetObjectItem(properties, "fun_type_name")->valuestring; const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_name)); @@ -3054,6 +3057,35 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std } } +void GraphDBClient::parseSVFStmtsForICFGNodeFromDBResult(SVFIR* pag) +{ + if (!icfgNode2StmtsStrMap.empty()) + { + for (auto& pair : icfgNode2StmtsStrMap) + { + ICFGNode* icfgNode = pair.first; + std::string svfStmtIds = pair.second; + if (!svfStmtIds.empty()) + { + std::list svfStmtIdsVec = parseElements2Container>(svfStmtIds); + for (int stmtId : svfStmtIdsVec) + { + SVFStmt* stmt = edgeId2SVFStmtMap[stmtId]; + if (stmt != nullptr) + { + pag->addToSVFStmtList(icfgNode,stmt); + icfgNode->addSVFStmt(stmt); + } + else + { + SVFUtil::outs() << "Warning: [parseSVFStmtsForICFGNodeFromDBResult] No matching SVFStmt found for id: " << stmtId << "\n"; + } + } + } + } + } +} + ICFGNode* GraphDBClient::parseGlobalICFGNodeFromDBResult(const cJSON* node) { cJSON* data = cJSON_GetObjectItem(node, "node"); @@ -3068,6 +3100,11 @@ ICFGNode* GraphDBClient::parseGlobalICFGNodeFromDBResult(const cJSON* node) int id = cJSON_GetObjectItem(properties,"id")->valueint; icfgNode = new GlobalICFGNode(id); + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } @@ -3123,7 +3160,11 @@ ICFGNode* GraphDBClient::parseFunEntryICFGNodeFromDBResult(const cJSON* node, SV { SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; } - + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } @@ -3181,6 +3222,11 @@ ICFGNode* GraphDBClient::parseFunExitICFGNodeFromDBResult(const cJSON* node, SVF SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; } + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } @@ -3228,6 +3274,12 @@ ICFGNode* GraphDBClient::parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR { SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; } + + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } @@ -3297,6 +3349,12 @@ ICFGNode* GraphDBClient::parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* { SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; } + + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } @@ -3428,6 +3486,11 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; } + std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; + if (!svfStmtIds.empty()) + { + icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; + } return icfgNode; } diff --git a/svf/lib/SVFIR/SVFVariables.cpp b/svf/lib/SVFIR/SVFVariables.cpp index af52b4e0d..a633d408c 100644 --- a/svf/lib/SVFIR/SVFVariables.cpp +++ b/svf/lib/SVFIR/SVFVariables.cpp @@ -877,7 +877,7 @@ std::string FunObjVar::toDBString() const + ", intrinsic:" + (isIntrinsic()? "true" : "false") + ", is_addr_taken:" + (hasAddressTaken()? "true" : "false") + ", is_uncalled:" + (isUncalledFunction()? "true" : "false") - + ", is_not_ret:" + (hasReturn()? "true" : "false") + + ", is_not_ret:" + (getIsNotRet()? "true" : "false") + ", sup_var_arg:" + (isVarArg()? "true" : "false") + ", fun_type_name:'" + getFunctionType()->toString() + "'" + ", real_def_fun_node_id:" + std::to_string(getDefFunForMultipleModule()->getId()) From 52d98fbb50b37bb82009346a830cab2f25c71b4a Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Thu, 19 Jun 2025 15:55:34 +1000 Subject: [PATCH 05/19] add annotations to funObjVar --- .../Graphs/DBSchema/PAGNodeSchema.json | 6 +++++ svf/include/SVFIR/GraphDBClient.h | 27 +++++++++++++++++++ svf/include/Util/ExtAPI.h | 1 + svf/lib/SVFIR/SVFVariables.cpp | 8 ++++++ 4 files changed, 42 insertions(+) diff --git a/svf/include/Graphs/DBSchema/PAGNodeSchema.json b/svf/include/Graphs/DBSchema/PAGNodeSchema.json index 3772e8849..8ee26acf0 100644 --- a/svf/include/Graphs/DBSchema/PAGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/PAGNodeSchema.json @@ -685,6 +685,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"func_annotation", + "type":"STRING", + "optional":false, + "index":false } ] }, diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 4296010bb..21a2f2008 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -779,6 +779,33 @@ class GraphDBClient int bbId = std::stoi(idStr.substr(colonPos + 1)); return std::make_pair(functionId, bbId); } + + std::string serializeAnnotations(const std::vector& annotations) + { + std::string result; + for (size_t i = 0; i < annotations.size(); ++i) + { + result += annotations[i].c_str(); + if (i < annotations.size() - 1) + result += ", "; + } + return result; + } + + std::vector deserializeAnnotations(const std::string& annotationsStr) + { + std::vector result; + std::istringstream iss(annotationsStr); + std::string token; + while (std::getline(iss, token, ',')) + { + token.erase(0, token.find_first_not_of(" \t")); + token.erase(token.find_last_not_of(" \t") + 1); + if (!token.empty()) + result.push_back(token); + } + return result; + } }; } // namespace SVF diff --git a/svf/include/Util/ExtAPI.h b/svf/include/Util/ExtAPI.h index cf949bbe6..d7ebf326b 100644 --- a/svf/include/Util/ExtAPI.h +++ b/svf/include/Util/ExtAPI.h @@ -47,6 +47,7 @@ class ExtAPI { friend class LLVMModuleSet; friend class SVFIRBuilder; + friend class GraphDBClient; private: diff --git a/svf/lib/SVFIR/SVFVariables.cpp b/svf/lib/SVFIR/SVFVariables.cpp index a633d408c..a81975977 100644 --- a/svf/lib/SVFIR/SVFVariables.cpp +++ b/svf/lib/SVFIR/SVFVariables.cpp @@ -870,6 +870,13 @@ std::string FunObjVar::toDBString() const { exitBBStr << ", exit_bb_id:-1"; } + std::string annotationsStr = ""; + std::vector annotationsVector; + annotationsVector = ExtAPI::getExtAPI()->getExtFuncAnnotations(this); + if (annotationsVector.size() > 0) + { + annotationsStr = GraphDBClient::getInstance().serializeAnnotations(annotationsVector); + } const std::string queryStatement ="CREATE (n:FunObjVar {"+ getBaseObjVarNodeFieldsStmt() + ", kind:" + std::to_string(getNodeKind()) @@ -891,6 +898,7 @@ std::string FunObjVar::toDBString() const + ", bb2_loop_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getLoopAndDomInfo()->getBB2LoopMap())) + "'" + ", bb2_p_dom_level:'" + GraphDBClient::getInstance().extractLabelMap2String(&(getLoopAndDomInfo()->getBBPDomLevel())) + "'" + ", bb2_pi_dom:'" + GraphDBClient::getInstance().extractBBsMap2String(&(getLoopAndDomInfo()->getBB2PIdom())) + "'" + + ", func_annotation:'" + annotationsStr + "'" + "})"; return queryStatement; } From c60818cb675c3cdc4de4749d1ea384bb159e86b9 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sun, 27 Jul 2025 17:29:08 +1000 Subject: [PATCH 06/19] update "update allICFGNode of BB from DB result" add node location info to db fix rebase err --- svf/include/Graphs/CallGraph.h | 18 + .../Graphs/DBSchema/CHGNodeSchema.json | 6 + .../Graphs/DBSchema/CallGraphNodeSchema.json | 6 + .../Graphs/DBSchema/ICFGNodeSchema.json | 56 +- .../Graphs/DBSchema/PAGEdgeSchema.json | 6 +- .../Graphs/DBSchema/PAGNodeSchema.json | 350 +++++++--- .../Graphs/DBSchema/SVFTypeNodeSchema.json | 102 +-- svf/include/Graphs/ICFGNode.h | 27 +- svf/include/Graphs/IRGraph.h | 6 +- svf/include/SVFIR/GraphDBClient.h | 45 +- svf/include/SVFIR/SVFIR.h | 15 +- svf/include/SVFIR/SVFVariables.h | 26 + svf/lib/Graphs/ICFG.cpp | 28 +- svf/lib/SVFIR/GraphDBClient.cpp | 626 ++++++++++-------- svf/lib/SVFIR/SVFIR.cpp | 1 + svf/lib/SVFIR/SVFStatements.cpp | 10 +- svf/lib/SVFIR/SVFVariables.cpp | 32 +- 17 files changed, 897 insertions(+), 463 deletions(-) diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index 27120d079..cb7f87db4 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -165,6 +165,7 @@ class CallGraphEdge : public GenericPTACallGraphEdgeTy typedef GenericNode::GEdgeSetTy CallGraphEdgeSet; + std::string toDBString() const; }; class FunObjVar; @@ -224,6 +225,23 @@ class CallGraphNode : public GenericPTACallGraphNodeTy { return node->getNodeKind() == CallNodeKd; } + + std::string toDBString() const; + + + std::string sourceLocToDBString() const + { + std::string sourceLoc = ""; + if (getSourceLoc().empty() == false) + { + sourceLoc = ", source_loc: '" + getSourceLoc() + "'"; + } + else + { + sourceLoc = ", source_loc: ''"; + } + return sourceLoc; + } //@} }; diff --git a/svf/include/Graphs/DBSchema/CHGNodeSchema.json b/svf/include/Graphs/DBSchema/CHGNodeSchema.json index 4789d08fa..c3841c4dd 100644 --- a/svf/include/Graphs/DBSchema/CHGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/CHGNodeSchema.json @@ -28,6 +28,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json index f3a24f061..d8a227d4e 100644 --- a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json +++ b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json @@ -16,6 +16,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json index ee3b7bb00..caf000d30 100644 --- a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json @@ -22,6 +22,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -65,6 +71,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -90,6 +102,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -133,6 +151,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -176,6 +200,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -215,8 +245,8 @@ "index":false }, { - "name":"svf_type", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "index":false, "optional":false }, @@ -267,6 +297,18 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"ind_fun_ptr_var_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -300,8 +342,8 @@ "index":false }, { - "name":"svf_type", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "index":false, "optional":false }, @@ -322,6 +364,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json index 439f2ee3b..7a5a251d3 100644 --- a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json +++ b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json @@ -527,9 +527,9 @@ "index":false }, { - "name":"ap_gep_pointee_type_name", - "type":"STRING", - "optional":true, + "name":"ap_gep_pointee_type_id", + "type":"INT32", + "optional":false, "index":false }, { diff --git a/svf/include/Graphs/DBSchema/PAGNodeSchema.json b/svf/include/Graphs/DBSchema/PAGNodeSchema.json index 8ee26acf0..f3baf0d79 100644 --- a/svf/include/Graphs/DBSchema/PAGNodeSchema.json +++ b/svf/include/Graphs/DBSchema/PAGNodeSchema.json @@ -18,8 +18,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -34,6 +34,12 @@ "type":"STRING", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -55,8 +61,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -77,6 +83,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -98,8 +110,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -114,6 +126,12 @@ "type":"STRING", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -135,8 +153,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -169,6 +187,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -190,8 +214,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -220,8 +244,8 @@ "index":false }, { - "name":"gep_val_svf_type_name", - "type":"STRING", + "name":"gep_val_svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -232,9 +256,9 @@ "index":false }, { - "name":"ap_gep_pointee_type_name", - "type":"STRING", - "optional":true, + "name":"ap_gep_pointee_type_id", + "type":"INT32", + "optional":false, "index":false }, { @@ -242,6 +266,18 @@ "type":"STRING", "optional":true, "index":false + }, + { + "name":"llvm_var_inst_id", + "type":"INT32", + "optional":false, + "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -263,8 +299,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -287,8 +323,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -315,6 +351,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -336,8 +378,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -364,6 +406,12 @@ "type":"INT64", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -385,8 +433,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -409,8 +457,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -437,6 +485,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -458,8 +512,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -482,8 +536,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -510,6 +564,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -531,8 +591,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -555,8 +615,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -621,8 +681,8 @@ "index":false }, { - "name":"fun_type_name", - "type":"STRING", + "name":"fun_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -691,6 +751,18 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"val_name", + "type":"STRING", + "optional":false, + "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -712,8 +784,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -740,6 +812,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -761,8 +839,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -783,6 +861,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -804,8 +888,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -826,6 +910,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -847,8 +937,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -869,6 +959,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -890,8 +986,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -912,6 +1008,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -933,8 +1035,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -961,6 +1063,12 @@ "type":"DOUBLE", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -982,8 +1090,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1016,6 +1124,12 @@ "type":"INT64", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1037,8 +1151,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1059,6 +1173,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1080,8 +1200,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1104,8 +1224,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1132,6 +1252,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1153,8 +1279,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1177,8 +1303,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1205,6 +1331,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1226,8 +1358,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1250,8 +1382,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1278,6 +1410,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1299,8 +1437,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1323,8 +1461,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1357,6 +1495,12 @@ "type":"FLOAT", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1378,8 +1522,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1402,8 +1546,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1442,6 +1586,12 @@ "type":"INT64", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1463,8 +1613,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1487,8 +1637,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1515,6 +1665,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1536,8 +1692,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1564,6 +1720,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1585,8 +1747,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1613,6 +1775,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1634,8 +1802,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1656,6 +1824,12 @@ "type":"INT32", "optional":false, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] }, @@ -1677,8 +1851,8 @@ "index":false }, { - "name":"svf_type_name", - "type":"STRING", + "name":"svf_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1701,8 +1875,8 @@ "index":false }, { - "name":"obj_type_info_type_name", - "type":"STRING", + "name":"obj_type_info_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -1729,6 +1903,12 @@ "type":"INT32", "optional":true, "index":false + }, + { + "name":"source_loc", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json index 46aa62de9..05719d24c 100644 --- a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json +++ b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json @@ -3,23 +3,23 @@ { "label" : "SVFPointerType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -46,23 +46,23 @@ { "label" : "SVFIntegerType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -95,23 +95,23 @@ { "label" : "SVFFunctionType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -134,8 +134,8 @@ "index":false }, { - "name":"ret_ty_node_name", - "type":"STRING", + "name":"ret_ty_node_id", + "type":"INT32", "optional":false, "index":false }, @@ -150,23 +150,23 @@ { "label" : "SVFStructType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -199,29 +199,35 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"fields_id_vec", + "type":"STRING", + "optional":false, + "index":false } ] }, { "label" : "SVFArrayType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -256,8 +262,8 @@ "index":false }, { - "name":"type_of_element_node_type_name", - "type":"STRING", + "name":"type_of_element_node_type_id", + "type":"INT32", "optional":false, "index":false } @@ -266,23 +272,23 @@ { "label" : "SVFOtherType", "type" : "VERTEX", - "primary" : "type_name", + "primary" : "id", "properties" : [ { - "name" : "type_name", - "type":"STRING", + "name" : "id", + "type":"INT32", "optional":false, "index":true }, { - "name":"svf_i8_type_name", - "type":"STRING", + "name":"svf_i8_type_id", + "type":"INT32", "optional":false, "index":false }, { - "name":"svf_ptr_type_name", - "type":"STRING", + "name":"svf_ptr_type_id", + "type":"INT32", "optional":false, "index":false }, @@ -315,10 +321,10 @@ { "label" : "StInfo", "type" : "VERTEX", - "primary" : "id", + "primary" : "st_info_id", "properties" : [ { - "name" : "id", + "name" : "st_info_id", "type":"INT32", "optional":false, "index":true diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index b6d7510f7..79e343ee8 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -140,7 +140,19 @@ class ICFGNode : public GenericICFGNodeTy return isICFGNodeKinds(node->getNodeKind()); } - + std::string sourceLocToDBString() const + { + std::string sourceLoc = ""; + if (getSourceLoc().empty() == false) + { + sourceLoc = ", source_loc: '" + getSourceLoc() + "'"; + } + else + { + sourceLoc = ", source_loc: ''"; + } + return sourceLoc; + } protected: const FunObjVar* fun; @@ -450,6 +462,7 @@ class CallICFGNode : public InterICFGNode SVFVar* vtabPtr; /// virtual table pointer s32_t virtualFunIdx; /// virtual function index of the virtual table(s) at a virtual call std::string funNameOfVcall; /// the function name of this virtual call + const SVFVar* indFunPtr; /// Constructor to create empty CallICFGNode (for SVFIRReader/deserialization) CallICFGNode(NodeID id) : InterICFGNode(id, FunCallBlock), ret{} {} @@ -618,6 +631,18 @@ class CallICFGNode : public InterICFGNode } std::string toDBString() const; + + inline void setIndFunPtr(const SVFVar* indFun) + { + assert(isIndirectCall() && "not a indirect call?"); + indFunPtr = indFun; + } + + inline const SVFVar* getIndFunPtr() const + { + assert(isIndirectCall() && "not a indirect call?"); + return indFunPtr; + } }; diff --git a/svf/include/Graphs/IRGraph.h b/svf/include/Graphs/IRGraph.h index 5de5fb3a6..fc996c9a6 100644 --- a/svf/include/Graphs/IRGraph.h +++ b/svf/include/Graphs/IRGraph.h @@ -272,11 +272,11 @@ class IRGraph : public GenericGraph return svfTypes; } - inline const SVFType* getSVFType(const std::string& name) const + inline const SVFType* getSVFType(u32_t id) const { for(const SVFType* type : svfTypes) { - if(type->toString() == name) + if(type->getId() == id) return type; } return nullptr; @@ -416,4 +416,4 @@ template<> struct GenericGraphTraits : public GenericGraphTraits< }; } // End namespace llvm -#endif /* IRGRAPH_H_ */ +#endif /* IRGRAPH_H_ */ \ No newline at end of file diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 21a2f2008..4885ff73d 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -125,6 +125,7 @@ class GraphDBClient void readBasicBlockGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname); void readBasicBlockNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); void readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); + void updateBasicBlockNodes(ICFG* icfg); /// read ICFGNodes & ICFGEdge from DB ICFG* buildICFGFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); @@ -166,6 +167,20 @@ class GraphDBClient void readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag); void parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap); void parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes); + std::string parseNodeSourceLocation(cJSON* node) const + { + cJSON* data = cJSON_GetObjectItem(node, "node"); + if (!data) + return ""; + + cJSON* properties = cJSON_GetObjectItem(data, "properties"); + if (!properties) + return ""; + + std::string sourceLocation = cJSON_GetObjectItem(properties, "source_loc")->valuestring; + + return sourceLocation.empty() ? "" : sourceLocation; + } ObjTypeInfo* parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag); @@ -297,20 +312,19 @@ class GraphDBClient auto it = types.begin(); - typesStr << "{" << (*it)->toString() << "}"; + typesStr << "{" << (*it)->getId() << "}"; ++it; for (; it != types.end(); ++it) { - typesStr << "," << "{" << (*it)->toString() << "}"; + typesStr << "," << "{" << (*it)->getId() << "}"; } return typesStr.str(); } template - Container parseElementsToSVFTypeContainer( - std::string& str, const Map& typeMap) + Container parseElementsToSVFTypeContainer(std::string& str, const Map& typeMap) { str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); @@ -332,7 +346,8 @@ class GraphDBClient token.erase(token.find_last_not_of(" \t") + 1); token.erase(0, token.find_first_not_of(" \t")); - auto it = typeMap.find(token); + int typeId = std::stoi(token); + auto it = typeMap.find(typeId); if (it != typeMap.end()) { resultContainer.insert(resultContainer.end(), it->second); @@ -350,13 +365,13 @@ class GraphDBClient return resultContainer; } - std::vector parseSVFTypes(std::string typesStr) + std::vector parseSVFTypes(std::string typesStr) { typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\n'), typesStr.end()); typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\r'), typesStr.end()); - std::vector result; + std::vector result; std::stringstream ss(typesStr); std::string token; @@ -370,7 +385,10 @@ class GraphDBClient { token.erase(token.size() - 1, 1); } - result.push_back(token); + if (!token.empty()) + { + result.push_back(std::stoi(token)); + } } return result; @@ -387,19 +405,19 @@ class GraphDBClient std::ostringstream mapStr; auto it = fldIdx2TypeMap.begin(); - mapStr << "{" << it->first << ":" << it->second->toString() << "}"; + mapStr << "{" << it->first << ":" << it->second->getId() << "}"; ++it; for (; it != fldIdx2TypeMap.end(); ++it) { - mapStr << ",{" << it->first << ":" << it->second->toString() << "}"; + mapStr << ",{" << it->first << ":" << it->second->getId() << "}"; } return mapStr.str(); } template - MapType parseStringToFldIdx2TypeMap(const std::string& str, const Map& typeMap) + MapType parseStringToFldIdx2TypeMap(const std::string& str, const Map& typeMap) { MapType resultMap; @@ -422,10 +440,11 @@ class GraphDBClient if (colonPos != std::string::npos) { std::string keyStr = token.substr(0, colonPos); std::string typeStr = token.substr(colonPos + 1); + int typeId = std::stoi(typeStr); u32_t key = static_cast(std::stoi(keyStr)); - auto it = typeMap.find(typeStr); + auto it = typeMap.find(typeId); if (it != typeMap.end()) { resultMap[key] = it->second; } else { @@ -672,7 +691,7 @@ class GraphDBClient std::ostringstream oss; if (nullptr != pair.first && nullptr != pair.second) { - oss << "{" << pair.first->getId() << ", " << pair.second->toString() + oss << "{" << pair.first->getId() << ", " << pair.second->getId() << "}"; return oss.str(); } diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index 55ebc6d4f..2231b51d2 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -746,7 +746,7 @@ class SVFIR : public IRGraph inline NodeID addConstantAggObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { memToFieldsMap[i].set(i); - ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, type, node); + ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, type, node); return addObjNode(conObj); } inline NodeID addConstantDataObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) @@ -855,7 +855,18 @@ class SVFIR : public IRGraph /// Add callsites inline void addCallSite(const CallICFGNode* call) { - callSiteSet.insert(call); + // if (call->getId() == 9889 ||call->getId() == 9914 ||call->getId() == 9922 ||call->getId() == 9944 ||call->getId() == 10733 ||call->getId() == 10741 ||call->getId() == 10762 ||call->getId() == 10770 ) + // { + + // } else { + callSiteSet.insert(call); + // SVFUtil::outs()<< "Adding callsite: " << call->getId() << "\n"; + // } + } + + inline void addGepValObjFromDB(NodeID curInstID, const GepValVar* gepValvar) + { + GepValObjMap[curInstID][std::make_pair(gepValvar->getBaseNode()->getId(), gepValvar->getAccessPath())] = gepValvar->getId(); } /// Add an edge into SVFIR //@{ diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index db9cd2a3a..f9b1cb4f5 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -202,6 +202,20 @@ class SVFVar : public GenericPAGNodeTy return false; } + std::string sourceLocToDBString() const + { + std::string sourceLoc = ""; + if (getSourceLoc().empty() == false) + { + sourceLoc = ", source_loc: '" + getSourceLoc() + "'"; + } + else + { + sourceLoc = ", source_loc: ''"; + } + return sourceLoc; + } + private: /// Edge management methods @@ -474,6 +488,7 @@ class GepValVar: public ValVar AccessPath ap; // AccessPath const ValVar* base; // base node const SVFType* gepValType; + NodeID llvmVarID; public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -573,6 +588,17 @@ class GepValVar: public ValVar } std::string toDBString() const; + /// Get the LLVM variable ID associated with this GepValVar + inline NodeID getLLVMVarInstID() const + { + return llvmVarID; + } + + /// Set the LLVM variable ID associated with this GepValVar + inline void setLLVMVarInstID(NodeID id) + { + llvmVarID = id; + } }; /* diff --git a/svf/lib/Graphs/ICFG.cpp b/svf/lib/Graphs/ICFG.cpp index 534f3c77d..7dc80b32d 100644 --- a/svf/lib/Graphs/ICFG.cpp +++ b/svf/lib/Graphs/ICFG.cpp @@ -54,7 +54,8 @@ std::string FunEntryICFGNode::toDBString() const ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + ", bb_id:" + std::to_string(getBB()->getId()) + - ", fp_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getFormalParms()) +"'})"; + ", fp_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getFormalParms()) +"'"+ + sourceLocToDBString() + "})"; return queryStatement; } @@ -83,7 +84,7 @@ std::string FunExitICFGNode::toDBString() const ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + ", bb_id:" + std::to_string(getBB()->getId()) + - formalRetId + "})"; + formalRetId + sourceLocToDBString() + "})"; return queryStatement; } @@ -186,6 +187,11 @@ std::string CallICFGNode::toDBString() const std::string virtual_fun_idx = ""; std::string is_vir_call_inst = isVirtualCall() ? "true" : "false"; std::string virtualFunAppendix = ""; + int indFunPtrId = -1; + if (isIndirectCall()) + { + indFunPtrId = getIndFunPtr()->getId(); + } if (isVirtualCall()) { fun_name_of_v_call = ", fun_name_of_v_call: '"+getFunNameOfVirtualCall()+"'"; @@ -223,12 +229,13 @@ std::string CallICFGNode::toDBString() const ", bb_id: " + std::to_string(getBB()->getId()) + ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", svf_type:'" + getType()->toString() + "'" + + ", svf_type_id:" + std::to_string(getType()->getId()) + ", ap_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getActualParms()) +"'" + called_fun_obj_var_id + ", is_vararg: " + (isVarArg() ? "true" : "false") + ", is_vir_call_inst: " + (isVirtualCall() ? "true" : "false") + - virtualFunAppendix+"})"; + ", ind_fun_ptr_var_id:" + std::to_string(indFunPtrId) + + virtualFunAppendix+ sourceLocToDBString() +"})"; return queryStatement; } @@ -261,7 +268,7 @@ std::string RetICFGNode::toDBString() const ", bb_id: " + std::to_string(getBB()->getId()) + ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", svf_type:'" + getType()->toString() + "'"+"})"; + ", svf_type_id:" + std::to_string(getType()->getId()) + sourceLocToDBString() + "})"; return queryStatement; } @@ -653,14 +660,16 @@ std::string IntraICFGNode::toDBString() const ", is_return: " + (isRetInst() ? "true" : "false") + ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(getBB()->getId()) + "})"; + ", bb_id:" + std::to_string(getBB()->getId()) + + sourceLocToDBString() + "})"; return queryStatement; } std::string InterICFGNode::toDBString() const{ const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(getId()) + ", kind: " + std::to_string(getNodeKind()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'})"; + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'"+ + sourceLocToDBString() + "})"; return queryStatement; } @@ -668,7 +677,8 @@ std::string GlobalICFGNode::toDBString() const { const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(getId()) + ", kind: " + std::to_string(getNodeKind()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'})"; + ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'"+ + sourceLocToDBString() + "})"; return queryStatement; } /*! @@ -781,4 +791,4 @@ struct DOTGraphTraits : public DOTGraphTraits return rawstr.str(); } }; -} // End namespace llvm +} // End namespace llvm \ No newline at end of file diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index e0c27251d..2d39b2a40 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -12,6 +12,7 @@ Map callCFGEdge2CallPEStrMap; Map retCFGEdge2RetPEStrMap; Map icfgNode2StmtsStrMap; Map edgeId2SVFStmtMap; +Map bb2AllICFGNodeIdstrMap; bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, const std::string& filepath, @@ -151,8 +152,7 @@ bool GraphDBClient::addCallGraphNode2db(lgraph::RpcClient* connection, { if (nullptr != connection) { - const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(node->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) +"})"; + const std::string queryStatement = node->toDBString(); // SVFUtil::outs()<<"CallGraph Node Insert Query:"<CallCypher(result, queryStatement, dbname); @@ -172,28 +172,7 @@ bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, { if (nullptr != connection) { - std::string indirectCallIds = ""; - Set indirectCall = edge->getIndirectCalls(); - if (indirectCall.size() > 0) - { - indirectCallIds = extractNodesIds(indirectCall); - } - - std::string directCallIds = ""; - Set directCall = edge->getDirectCalls(); - if (directCall.size() > 0) - { - directCallIds = extractNodesIds(directCall); - } - - const std::string queryStatement = - "MATCH (n:CallGraphNode{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(edge->getDstNode()->getId()) + "}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(edge->getCallSiteID()) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + - indirectCallIds + "'}]->(m)"; + const std::string queryStatement = edge->toDBString(); // SVFUtil::outs() << "Call Graph Edge Insert Query:" << queryStatement << "\n"; std::string result; bool ret = connection->CallCypher(result, queryStatement, dbname); @@ -202,6 +181,7 @@ bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, SVFUtil::outs() << "Warining: Failed to add callgraph edge to db " << dbname << " " << result << "\n"; } + // SVFUtil::outs()<<"CallGraph Edge Insert Query:"< edges; @@ -398,9 +378,9 @@ void GraphDBClient::insertCallGraph2db(const CallGraph* callGraph) { std::string callGraphNodePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json"; std::string callGraphEdgePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json"; // add all CallGraph Node & Edge to DB if (nullptr != connection) { @@ -446,7 +426,7 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co // create a new graph name SVFType in db createSubGraph(connection, "SVFType"); // load schema for SVFType - loadSchema(connection, SVF_ROOT "/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json", "SVFType"); + loadSchema(connection, SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json", "SVFType"); // load & insert each svftype node to db for (const auto& ty : *types) @@ -573,13 +553,13 @@ void GraphDBClient::insertBBNode2db(lgraph::RpcClient* connection, const SVFBasi void GraphDBClient::insertPAG2db(const PAG* pag) { std::string pagNodePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; std::string pagEdgePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/PAGEdgeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/PAGEdgeSchema.json"; std::string bbNodePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json"; std::string bbEdgePath = - SVF_ROOT "/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json"; + SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json"; // add all PAG Node & Edge to DB if (nullptr != connection) @@ -991,14 +971,15 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st // parse all SVFType std::string queryStatement = "MATCH (node) WHERE NOT 'StInfo' IN labels(node) return node"; - Map svfTypeMap; + Map svfTypeMap; Map stInfoMap; // Map> svfTypeKind2SVFTypesMap; - Map> svfi8AndPtrTypeMap; - Map> functionRetTypeSetMap; - Map> functionParamsTypeSetMap; + Map> svfi8AndPtrTypeMap; + Map> functionRetTypeSetMap; + Map> functionParamsTypeSetMap; Map> stInfoId2SVFTypeMap; - Map> elementTyepsMap; + Map> elementTyepsMap; + Map> structType2FieldsTypeIdMap; cJSON* root = queryFromDB(connection, dbname, queryStatement); cJSON* node; @@ -1017,22 +998,20 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st std::string label = cJSON_GetObjectItem(data, "label")->valuestring; SVFType* type = nullptr; - std::string i8Type = - cJSON_GetObjectItem(properties, "svf_i8_type_name") - ->valuestring; - std::string ptrType = - cJSON_GetObjectItem(properties, "svf_ptr_type_name") - ->valuestring; + int i8Type = + cJSON_GetObjectItem(properties, "svf_i8_type_id")->valueint; + int ptrType = + cJSON_GetObjectItem(properties, "svf_ptr_type_id")->valueint; bool svt = cJSON_IsTrue( cJSON_GetObjectItem(properties, "is_single_val_ty")); int byteSize = cJSON_GetObjectItem(properties, "byte_size")->valueint; - std::string typeNameString = - cJSON_GetObjectItem(properties, "type_name")->valuestring; + int typeId = + cJSON_GetObjectItem(properties, "id")->valueint; if (label == "SVFPointerType") { - type = new SVFPointerType(byteSize, svt); + type = new SVFPointerType(typeId, byteSize, svt); } else if (label == "SVFIntegerType") { @@ -1040,46 +1019,45 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st cJSON_GetObjectItem(properties, "single_and_width"); short single_and_width = (short)cJSON_GetNumberValue(single_and_width_Json); - type = new SVFIntegerType(byteSize, svt, single_and_width); + type = new SVFIntegerType(typeId, byteSize, svt, single_and_width); } else if (label == "SVFFunctionType") { - SVFFunctionType* funType = new SVFFunctionType(svt, byteSize); + SVFFunctionType* funType = new SVFFunctionType(typeId, svt, byteSize); type = funType; - std::string retTypeName = - cJSON_GetObjectItem(properties, "ret_ty_node_name") - ->valuestring; - auto it = svfTypeMap.find(retTypeName); + int retTypeId = cJSON_GetObjectItem(properties, "ret_ty_node_id") ->valueint; + auto it = svfTypeMap.find(retTypeId); if (it != svfTypeMap.end()) { funType->setReturnType(it->second); } else { - functionRetTypeSetMap[retTypeName].insert(funType); + functionRetTypeSetMap[retTypeId].insert(funType); } - std::string paramsTypes = - cJSON_GetObjectItem(properties, "params_types_vec") - ->valuestring; + std::string paramsTypes = cJSON_GetObjectItem(properties, "params_types_vec")->valuestring; if (!paramsTypes.empty()) { - functionParamsTypeSetMap[funType] = - parseSVFTypes(paramsTypes); + functionParamsTypeSetMap[funType] = parseSVFTypes(paramsTypes); } } else if (label == "SVFOtherType") { std::string repr = cJSON_GetObjectItem(properties, "repr")->valuestring; - type = new SVFOtherType(svt, byteSize, repr); + type = new SVFOtherType(typeId, svt, byteSize, repr); } else if (label == "SVFStructType") { - std::string name = - cJSON_GetObjectItem(properties, "struct_name")->valuestring; - type = new SVFStructType(svt, byteSize, name); - int stInfoID = - cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; + std::string name = cJSON_GetObjectItem(properties, "struct_name")->valuestring; + SVFStructType* structType = new SVFStructType(typeId, svt, byteSize, name); + type = structType; + std::string fieldTypesStr = cJSON_GetObjectItem(properties, "fields_id_vec")->valuestring; + if (!fieldTypesStr.empty()) + { + structType2FieldsTypeIdMap[structType] = parseSVFTypes(fieldTypesStr); + } + int stInfoID = cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; auto it = stInfoMap.find(stInfoID); if (it != stInfoMap.end()) { @@ -1092,13 +1070,10 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st } else if (label == "SVFArrayType") { - int numOfElement = - cJSON_GetObjectItem(properties, "num_of_element")->valueint; - SVFArrayType* arrayType = - new SVFArrayType(svt, byteSize, numOfElement); + int numOfElement = cJSON_GetObjectItem(properties, "num_of_element")->valueint; + SVFArrayType* arrayType = new SVFArrayType(typeId, svt, byteSize, numOfElement); type = arrayType; - int stInfoID = - cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; + int stInfoID = cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; auto stInfoIter = stInfoMap.find(stInfoID); if (stInfoIter != stInfoMap.end()) { @@ -1108,21 +1083,18 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st { stInfoId2SVFTypeMap[stInfoID].insert(type); } - std::string typeOfElementName = - cJSON_GetObjectItem(properties, - "type_of_element_node_type_name") - ->valuestring; - auto tyepIter = svfTypeMap.find(typeOfElementName); + int typeOfElementId = cJSON_GetObjectItem(properties,"type_of_element_node_type_id")->valueint; + auto tyepIter = svfTypeMap.find(typeOfElementId); if (tyepIter != svfTypeMap.end()) { arrayType->setTypeOfElement(tyepIter->second); } else { - elementTyepsMap[typeOfElementName].insert(arrayType); + elementTyepsMap[typeOfElementId].insert(arrayType); } } - svfTypeMap.emplace(typeNameString, type); + svfTypeMap.emplace(typeId, type); // svfTypeKind2SVFTypesMap[type->getSVFTyKind()].insert(type); svfi8AndPtrTypeMap[type] = std::make_pair(i8Type, ptrType); } @@ -1144,57 +1116,33 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st if (!properties) continue; - u32_t id = static_cast( - cJSON_GetObjectItem(properties, "id")->valueint); - std::string fld_idx_vec = - cJSON_GetObjectItem(properties, "fld_idx_vec")->valuestring; - std::vector fldIdxVec = - parseElements2Container>(fld_idx_vec); - - std::string elem_idx_vec = - cJSON_GetObjectItem(properties, "elem_idx_vec")->valuestring; - std::vector elemIdxVec = - parseElements2Container>(elem_idx_vec); - - std::string fld_idx_2_type_map = - cJSON_GetObjectItem(properties, "fld_idx_2_type_map") - ->valuestring; - Map fldIdx2TypeMap = - parseStringToFldIdx2TypeMap>( - fld_idx_2_type_map, svfTypeMap); - - std::string finfo_types = - cJSON_GetObjectItem(properties, "finfo_types")->valuestring; - std::vector finfo = - parseElementsToSVFTypeContainer>( - finfo_types, svfTypeMap); - - u32_t stride = static_cast( - cJSON_GetObjectItem(properties, "stride")->valueint); - u32_t num_of_flatten_elements = static_cast( - cJSON_GetObjectItem(properties, "num_of_flatten_elements") - ->valueint); - u32_t num_of_flatten_fields = static_cast( - cJSON_GetObjectItem(properties, "num_of_flatten_fields") - ->valueint); - std::string flatten_element_types = - cJSON_GetObjectItem(properties, "flatten_element_types") - ->valuestring; - std::vector flattenElementTypes = - parseElementsToSVFTypeContainer>( - flatten_element_types, svfTypeMap); - StInfo* stInfo = - new StInfo(id, fldIdxVec, elemIdxVec, fldIdx2TypeMap, finfo, - stride, num_of_flatten_elements, - num_of_flatten_fields, flattenElementTypes); + u32_t id = static_cast(cJSON_GetObjectItem(properties, "st_info_id")->valueint); + std::string fld_idx_vec = cJSON_GetObjectItem(properties, "fld_idx_vec")->valuestring; + std::vector fldIdxVec = parseElements2Container>(fld_idx_vec); + + std::string elem_idx_vec = cJSON_GetObjectItem(properties, "elem_idx_vec")->valuestring; + std::vector elemIdxVec = parseElements2Container>(elem_idx_vec); + + std::string fld_idx_2_type_map = cJSON_GetObjectItem(properties, "fld_idx_2_type_map")->valuestring; + Map fldIdx2TypeMap = parseStringToFldIdx2TypeMap>(fld_idx_2_type_map, svfTypeMap); + + std::string finfo_types = cJSON_GetObjectItem(properties, "finfo_types")->valuestring; + std::vector finfo = parseElementsToSVFTypeContainer>(finfo_types, svfTypeMap); + + u32_t stride = static_cast(cJSON_GetObjectItem(properties, "stride")->valueint); + u32_t num_of_flatten_elements = static_cast(cJSON_GetObjectItem(properties, "num_of_flatten_elements")->valueint); + u32_t num_of_flatten_fields = static_cast(cJSON_GetObjectItem(properties, "num_of_flatten_fields")->valueint); + std::string flatten_element_types =cJSON_GetObjectItem(properties, "flatten_element_types")->valuestring; + std::vector flattenElementTypes =parseElementsToSVFTypeContainer>(flatten_element_types, svfTypeMap); + StInfo* stInfo =new StInfo(id, fldIdxVec, elemIdxVec, fldIdx2TypeMap, finfo,stride, num_of_flatten_elements,num_of_flatten_fields, flattenElementTypes); stInfoMap[id] = stInfo; } cJSON_Delete(root); } - for (auto& [retTypeName, types]:functionRetTypeSetMap) + for (auto& [retTypeId, types]:functionRetTypeSetMap) { - auto retTypeIter = svfTypeMap.find(retTypeName); + auto retTypeIter = svfTypeMap.find(retTypeId); if (retTypeIter != svfTypeMap.end()) { for (auto& type: types) @@ -1205,14 +1153,13 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st else { SVFUtil::outs() - << "Warning3: No matching SVFType found for type: " << retTypeName << "\n"; + << "Warning: No matching RetType found for typeId: " << retTypeId << "\n"; } } - Set ori = pag->getSVFTypes(); for (auto& [funType, paramsVec]:functionParamsTypeSetMap) { - for (const std::string& param : paramsVec) + for (const int param : paramsVec) { auto paramTypeIter = svfTypeMap.find(param); if (paramTypeIter != svfTypeMap.end()) @@ -1221,12 +1168,29 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st } else { - SVFUtil::outs()<<"Warning2: No matching SVFType found for type: " + SVFUtil::outs()<<"Warning: No matching paramType found for typeID: " << param << "\n"; } } } + for (auto& [structType, fieldTypes]:structType2FieldsTypeIdMap) + { + for (const int fieldTypeId : fieldTypes) + { + auto fieldTypeIter = svfTypeMap.find(fieldTypeId); + if (fieldTypeIter != svfTypeMap.end()) + { + structType->addFieldsType(fieldTypeIter->second); + } + else + { + SVFUtil::outs()<<"Warning: No matching fieldType found for typeID: " + << fieldTypeId << "\n"; + } + } + } + for (auto&[stInfoId, types] : stInfoId2SVFTypeMap) { auto stInfoIter = stInfoMap.find(stInfoId); @@ -1235,7 +1199,7 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st for (SVFType* type: types) { type->setTypeInfo(stInfoIter->second); - if (stInfoIter->second->getNumOfFlattenFields() > pag->maxStSize) + if (SVFUtil::isa(type) && stInfoIter->second->getNumOfFlattenFields() > pag->maxStSize) { pag->maxStSize = stInfoIter->second->getNumOfFlattenFields(); pag->maxStruct = type; @@ -1249,9 +1213,9 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st } } - for (auto& [elementTypesName, arrayTypes]:elementTyepsMap) + for (auto& [elementTypesId, arrayTypes]:elementTyepsMap) { - auto elementTypeIter = svfTypeMap.find(elementTypesName); + auto elementTypeIter = svfTypeMap.find(elementTypesId); if (elementTypeIter != svfTypeMap.end()) { for (SVFArrayType* type : arrayTypes) @@ -1261,15 +1225,15 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st } else { - SVFUtil::outs()<<"Warning1: No matching SVFType found for type: " - << elementTypesName << "\n"; + SVFUtil::outs()<<"Warning: No matching elementType found for typeId: " + << elementTypesId << "\n"; } } for (auto& [svfType, pair]:svfi8AndPtrTypeMap) { - std::string svfi8Type = pair.first; - std::string svfptrType = pair.second; + int svfi8Type = pair.first; + int svfptrType = pair.second; auto i8Type = svfTypeMap.find(svfi8Type); auto ptrType = svfTypeMap.find(svfptrType); if (i8Type!=svfTypeMap.end()) @@ -1281,7 +1245,7 @@ void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const st svfType->setSVFPtrType(ptrType->second); } } - for (auto& [typeName, type] : svfTypeMap) + for (auto& [typeId, type] : svfTypeMap) { pag->addTypeInfo(type); } @@ -1498,16 +1462,11 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: fldIdx = 0; } bool variant_field = cJSON_IsTrue(cJSON_GetObjectItem(properties,"variant_field")); - cJSON* ap_gep_pointee_type_name_node = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_name"); + int ap_gep_pointee_type_id = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_id")->valueint; const SVFType* gepPointeeType = nullptr; - std::string ap_gep_pointee_type_name = ""; - if (nullptr != ap_gep_pointee_type_name_node && nullptr != ap_gep_pointee_type_name_node->valuestring) + if (ap_gep_pointee_type_id != -1) { - ap_gep_pointee_type_name = ap_gep_pointee_type_name_node->valuestring; - if (!ap_gep_pointee_type_name.empty()) - { - gepPointeeType = pag->getSVFType(ap_gep_pointee_type_name); - } + gepPointeeType = pag->getSVFType(ap_gep_pointee_type_id); } AccessPath* ap = nullptr; if (nullptr != gepPointeeType) @@ -1517,8 +1476,8 @@ void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std: else { ap = new AccessPath(fldIdx); - if (!ap_gep_pointee_type_name.empty()) - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFType found for ap_gep_pointee_type_name: " << ap_gep_pointee_type_name << " when updating GepStmt:"<setCallEdgeLabelCounter(static_cast(call_edge_label_counter)); stmt->setStoreEdgeLabelCounter(static_cast(store_edge_label_counter)); stmt->setMultiOpndLabelCounter(static_cast(multi_opnd_label_counter)); - std::string inst2_label_map = cJSON_GetObjectItem(properties,"inst2_label_map")->valuestring; - std::string var2_label_map = cJSON_GetObjectItem(properties,"var2_label_map")->valuestring; + std::string inst2_label_map; + cJSON* inst2_label_map_item = cJSON_GetObjectItem(properties,"inst2_label_map"); + if (nullptr != inst2_label_map_item->valuestring) + { + inst2_label_map = inst2_label_map_item->valuestring; + } + else { + inst2_label_map = ""; + } + std::string var2_label_map; + cJSON* var2_label_map_item = cJSON_GetObjectItem(properties,"var2_label_map"); + if (nullptr != var2_label_map_item->valuestring) + { + var2_label_map = var2_label_map_item->valuestring; + } + else { + var2_label_map = ""; + } Map inst2_label_map_ids = parseLabelMapFromString>(inst2_label_map); Map var2_label_map_ids = parseLabelMapFromString>(var2_label_map); if (!inst2_label_map_ids.empty()) @@ -2165,16 +2140,11 @@ void GraphDBClient::updateGepValVarAttributes(cJSON* properties, GepValVar* var, << "\n"; } s64_t fldIdx = cJSON_GetObjectItem(properties, "ap_fld_idx")->valueint; - cJSON* ap_gep_pointee_type_name_node = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_name"); - std::string ap_gep_pointee_type_name = ""; - if (nullptr != ap_gep_pointee_type_name_node && nullptr != ap_gep_pointee_type_name_node->valuestring) - { - ap_gep_pointee_type_name = ap_gep_pointee_type_name_node->valuestring; - } + int ap_gep_pointee_type_id = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_id")->valueint; const SVFType* gepPointeeType = nullptr; - if (!ap_gep_pointee_type_name.empty()) + if (ap_gep_pointee_type_id != -1) { - gepPointeeType = pag->getSVFType(ap_gep_pointee_type_name); + gepPointeeType = pag->getSVFType(ap_gep_pointee_type_id); } AccessPath* ap = nullptr; if (nullptr != gepPointeeType) @@ -2184,8 +2154,8 @@ void GraphDBClient::updateGepValVarAttributes(cJSON* properties, GepValVar* var, else { ap = new AccessPath(fldIdx); - if (!ap_gep_pointee_type_name.empty()) - SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching SVFType found for ap_gep_pointee_type_name: " << ap_gep_pointee_type_name << " when updating GepValVar:"<getId()<< "\n"; + if (ap_gep_pointee_type_id != -1) + SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching SVFType found for ap_gep_pointee_type_id: " << ap_gep_pointee_type_id << " when updating GepValVar:"<getId()<< "\n"; } cJSON* ap_idx_operand_pairs_node = cJSON_GetObjectItem(properties, "ap_idx_operand_pairs"); @@ -2196,6 +2166,8 @@ void GraphDBClient::updateGepValVarAttributes(cJSON* properties, GepValVar* var, } parseAPIdxOperandPairsString(ap_idx_operand_pairs, pag, ap); var->setAccessPath(ap); + int llvm_var_inst_id = cJSON_GetObjectItem(properties, "llvm_var_inst_id")->valueint; + pag->addGepValObjFromDB(llvm_var_inst_id, var); } void GraphDBClient::parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap) @@ -2206,14 +2178,15 @@ void GraphDBClient::parseAPIdxOperandPairsString(const std::string& ap_idx_opera for(auto& pair : pairVec) { int varId = pair.first; - std::string typeName = pair.second; + std::string typeIdStr = pair.second; const SVFType* type; - if (typeName != "NULL") + if (typeIdStr != "NULL") { - type = pag->getSVFType(typeName); + int typeId = std::stoi(typeIdStr); + type = pag->getSVFType(typeId); if (nullptr == type) { - SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching SVFType found for type: " << typeName << " when parsing IdxOperandPair\n"; + SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching SVFType found for type: " << typeIdStr << " when parsing IdxOperandPair\n"; } } else @@ -2586,109 +2559,110 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: cJSON* properties = cJSON_GetObjectItem(data, "properties"); if (!properties) continue; + SVFVar* var = nullptr; int id = cJSON_GetObjectItem(properties,"id")->valueint; - std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type_name")->valuestring; - const SVFType* type = pag->getSVFType(svfTypeName); + int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; + const SVFType* type = pag->getSVFType(svfTypeId); if (type == nullptr) { - SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching SVFType found for type: " << svfTypeName << "for PAGNode:"<addInitValNodeFromDB(var); + var = new ConstNullPtrValVar(id, type, ValVar::ConstNullptrValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ConstIntValVar") { u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - ConstIntValVar* var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); - pag->addInitValNodeFromDB(var); + var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ConstFPValVar") { double dval = cJSON_GetObjectItem(properties, "dval")->valuedouble; - ConstFPValVar* var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); - pag->addInitValNodeFromDB(var); + var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ArgValVar") { u32_t arg_no = static_cast(cJSON_GetObjectItem(properties, "arg_no")->valueint); - ArgValVar* var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); - pag->addInitValNodeFromDB(var); + var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "BlackHoleValVar") { - BlackHoleValVar* var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); - pag->addInitValNodeFromDB(var); + var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ConstDataValVar") { - ConstDataValVar* var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); - pag->addInitValNodeFromDB(var); + var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "RetValPN") { - RetValPN* var = new RetValPN(id, type, ValVar::RetValNode); - pag->addInitValNodeFromDB(var); + var = new RetValPN(id, type, ValVar::RetValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "VarArgValPN") { - VarArgValPN* var = new VarArgValPN(id, type, ValVar::VarargValNode); - pag->addInitValNodeFromDB(var); + var = new VarArgValPN(id, type, ValVar::VarargValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "DummyValVar") { - DummyValVar* var = new DummyValVar(id, type, ValVar::DummyValNode); - pag->addInitValNodeFromDB(var); + var = new DummyValVar(id, type, ValVar::DummyValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ConstAggValVar") { - ConstAggValVar* var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); - pag->addInitValNodeFromDB(var); + var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "GlobalValVar") { - GlobalValVar* var = new GlobalValVar(id, type, ValVar::GlobalValNode); - pag->addInitValNodeFromDB(var); + var = new GlobalValVar(id, type, ValVar::GlobalValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "FunValVar") { - FunValVar* var = new FunValVar(id, type, ValVar::FunValNode); - pag->addInitValNodeFromDB(var); + var = new FunValVar(id, type, ValVar::FunValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "GepValVar") { - std::string gep_val_svf_type_name = cJSON_GetObjectItem(properties, "gep_val_svf_type_name")->valuestring; - const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_name); - GepValVar* var = new GepValVar(id, type, gepValType, ValVar::GepValNode); - pag->addInitValNodeFromDB(var); + int gep_val_svf_type_id = cJSON_GetObjectItem(properties, "gep_val_svf_type_id")->valueint; + const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_id); + var = new GepValVar(id, type, gepValType, ValVar::GepValNode); + pag->addInitValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ValVar") { - ValVar* var = new ValVar(id, type, ValVar::ValNode); - pag->addValNodeFromDB(var); + var = new ValVar(id, type, ValVar::ValNode); + pag->addValNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfValues(); } else if (nodeType == "ConstNullPtrObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstNullPtrObjVar* var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); - pag->addBaseObjNodeFromDB(var); + var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "ConstIntObjVar") @@ -2696,44 +2670,44 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - ConstIntObjVar* var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); - pag->addBaseObjNodeFromDB(var); + var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "ConstFPObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); float dval = (float)(cJSON_GetObjectItem(properties, "dval")->valuedouble); - ConstFPObjVar* var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); - pag->addBaseObjNodeFromDB(var); + var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "ConstDataObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstDataObjVar* var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); - pag->addBaseObjNodeFromDB(var); + var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "DummyObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - DummyObjVar* var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); - pag->addDummyObjNodeFromDB(var); + var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); + pag->addDummyObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "ConstAggObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - ConstAggObjVar* var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); - pag->addBaseObjNodeFromDB(var); + var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "GlobalObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - GlobalObjVar* var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); - pag->addBaseObjNodeFromDB(var); + var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "FunObjVar") @@ -2745,9 +2719,22 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_ret")); bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); - std::string fun_type_name = cJSON_GetObjectItem(properties, "fun_type_name")->valuestring; - const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_name)); - FunObjVar* var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); + int fun_type_id = cJSON_GetObjectItem(properties, "fun_type_id")->valueint; + const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_id)); + var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); + FunObjVar* funObjVar = SVFUtil::cast(var); + std::string func_annotation = cJSON_GetObjectItem(properties, "func_annotation")->valuestring; + if (!func_annotation.empty()) + { + std::vector func_annotation_vector; + func_annotation_vector = deserializeAnnotations(func_annotation); + ExtAPI::getExtAPI()->setExtFuncAnnotations(funObjVar, func_annotation_vector); + } + std::string val_name = cJSON_GetObjectItem(properties, "val_name")->valuestring; + if (!val_name.empty()) + { + funObjVar->setName(val_name); + } std::string all_args_node_ids = cJSON_GetObjectItem(properties, "all_args_node_ids")->valuestring; if (!all_args_node_ids.empty()) { @@ -2757,7 +2744,7 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: ArgValVar* arg = SVFUtil::dyn_cast(pag->getGNode(arg_id)); if (arg != nullptr) { - var->addArgument(arg); + funObjVar->addArgument(arg); } else { @@ -2765,29 +2752,29 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: } } } - pag->addBaseObjNodeFromDB(var); - id2funObjVarsMap[id] = var; + pag->addBaseObjNodeFromDB(funObjVar); + id2funObjVarsMap[id] = funObjVar; NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "StackObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - StackObjVar* var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); - pag->addBaseObjNodeFromDB(var); + var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "HeapObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - HeapObjVar* var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); - pag->addBaseObjNodeFromDB(var); + var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "BaseObjVar") { ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - BaseObjVar* var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); - pag->addBaseObjNodeFromDB(var); + var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); + pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "GepObjVar") @@ -2795,16 +2782,22 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: s64_t app_offset = cJSON_GetObjectItem(properties, "app_offset")->valueint; int base_obj_var_node_id = cJSON_GetObjectItem(properties, "base_obj_var_node_id")->valueint; const BaseObjVar* baseObj = pag->getBaseObject(base_obj_var_node_id); - GepObjVar* var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); - pag->addGepObjNodeFromDB(var); + var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); + pag->addGepObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } else if (nodeType == "ObjVar") { - ObjVar* var = new ObjVar(id, type, ObjVar::ObjNode); + var = new ObjVar(id, type, ObjVar::ObjNode); pag->addObjNodeFromDB(SVFUtil::cast(var)); NodeIDAllocator::get()->increaseNumOfObjAndNodes(); } + + std::string sourceLocation = parseNodeSourceLocation(node); + if (var != nullptr && !sourceLocation.empty()) + { + var->setSourceLoc(sourceLocation); + } skip += 1; } cJSON_Delete(root); @@ -2814,8 +2807,8 @@ void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std: ObjTypeInfo* GraphDBClient::parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag) { - std::string obj_type_info_type_name = cJSON_GetObjectItem(properties, "obj_type_info_type_name")->valuestring; - const SVFType* objTypeInfoType = pag->getSVFType(obj_type_info_type_name); + int obj_type_info_type_id = cJSON_GetObjectItem(properties, "obj_type_info_type_id")->valueint; + const SVFType* objTypeInfoType = pag->getSVFType(obj_type_info_type_id); int obj_type_info_flags = cJSON_GetObjectItem(properties, "obj_type_info_flags")->valueint; int obj_type_info_max_offset_limit = cJSON_GetObjectItem(properties, "obj_type_info_max_offset_limit")->valueint; int obj_type_info_elem_num = cJSON_GetObjectItem(properties, "obj_type_info_elem_num")->valueint; @@ -2872,8 +2865,8 @@ void GraphDBClient::readBasicBlockGraphFromDB(lgraph::RpcClient* connection, con void GraphDBClient::readBasicBlockNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) { - NodeID id = funObjVar->getId(); - std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(id) +" RETURN node "; + NodeID funObjId = funObjVar->getId(); + std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(funObjId) +" RETURN node "; cJSON* root = queryFromDB(connection, dbname, queryStatement); if (nullptr != root) { @@ -2896,12 +2889,40 @@ void GraphDBClient::readBasicBlockNodesFromDB(lgraph::RpcClient* connection, con bb->setName(bb_name); bbGraph->addBasicBlockFromDB(bb); basicBlocks.insert(bb); + std::string allICFGNodeIds = cJSON_GetObjectItem(properties, "all_icfg_nodes_ids")->valuestring; + if (!allICFGNodeIds.empty()) + bb2AllICFGNodeIdstrMap.insert(std::make_pair(bb, allICFGNodeIds)); } cJSON_Delete(root); } } +void GraphDBClient::updateBasicBlockNodes(ICFG* icfg) +{ + for (auto& item:bb2AllICFGNodeIdstrMap) + { + SVFBasicBlock* bb = item.first; + std::string allICFGNodeIds = item.second; + if (!allICFGNodeIds.empty()) + { + std::vector allICFGNodeIdsVec = parseElements2Container>(allICFGNodeIds); + for (int icfgId : allICFGNodeIdsVec) + { + ICFGNode* icfgNode = icfg->getICFGNode(icfgId); + if (icfgNode != nullptr) + { + bb->addICFGNode(icfgNode); + } + else + { + SVFUtil::outs() << "Warning: [updateBasicBlockNodes] No matching ICFGNode found for id: " << icfgId << "\n"; + } + } + } + } +} + void GraphDBClient::readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) { BasicBlockGraph* bbGraph = funObjVar->getBasicBlockGraph(); @@ -2975,6 +2996,8 @@ ICFG* GraphDBClient::buildICFGFromDB(lgraph::RpcClient* connection, const std::s readICFGEdgesFromDB(connection, dbname, "CallCFGEdge", icfg, pag); readICFGEdgesFromDB(connection, dbname, "RetCFGEdge", icfg, pag); + updateBasicBlockNodes(icfg); + return icfg; } @@ -3042,9 +3065,31 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseCallICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addCallICFGNodeFromDB(SVFUtil::cast(icfgNode)); + CallICFGNode* callNode = SVFUtil::cast(icfgNode); + icfg->addCallICFGNodeFromDB(callNode); + if (callNode->isIndirectCall()) + { + pag->addIndirectCallsites(callNode, callNode->getIndFunPtr()->getId()); + // SVFUtil::outs() << "Added indirect call site for node: " << callNode->getId() << "\n"; + pag->addCallSite(callNode); + } + else + { + const FunObjVar* calledFunc = callNode->getCalledFunction(); + if (calledFunc != nullptr && calledFunc->isIntrinsic() == false ) + { + // SVFUtil::outs() << "Added direct call site for node: " << callNode->getId() << "\n"; + pag->addCallSite(callNode); + } + } } } + + std::string sourceLocation = parseNodeSourceLocation(node); + if (!sourceLocation.empty()) + { + icfgNode->setSourceLoc(sourceLocation); + } if (nullptr == icfgNode) { @@ -3152,14 +3197,14 @@ ICFGNode* GraphDBClient::parseFunEntryICFGNodeFromDBResult(const cJSON* node, SV } } - if (nullptr != bb) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - } + // if (nullptr != bb) + // { + // bb->addICFGNode(icfgNode); + // } + // else + // { + // SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + // } std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; if (!svfStmtIds.empty()) { @@ -3213,14 +3258,14 @@ ICFGNode* GraphDBClient::parseFunExitICFGNodeFromDBResult(const cJSON* node, SVF } } - if (nullptr != bb) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - } + // if (nullptr != bb) + // { + // bb->addICFGNode(icfgNode); + // } + // else + // { + // SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + // } std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; if (!svfStmtIds.empty()) @@ -3265,15 +3310,15 @@ ICFGNode* GraphDBClient::parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR icfgNode = new IntraICFGNode(id, bb, funObjVar, is_return); - // add this ICFGNode to its BasicBlock - if (nullptr != bb) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - } + // // add this ICFGNode to its BasicBlock + // if (nullptr != bb) + // { + // bb->addICFGNode(icfgNode); + // } + // else + // { + // SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + // } std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; if (!svfStmtIds.empty()) @@ -3315,11 +3360,11 @@ ICFGNode* GraphDBClient::parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); // parse retICFGNode svfType - std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type")->valuestring; - const SVFType* type = pag->getSVFType(svfTypeName); + int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; + const SVFType* type = pag->getSVFType(svfTypeId); if (nullptr == type) { - SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeName << "\n"; + SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeId << "\n"; } // create RetICFGNode Instance @@ -3340,15 +3385,15 @@ ICFGNode* GraphDBClient::parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* } } - // add this ICFGNode to its BasicBlock - if (nullptr != bb) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - } + // // add this ICFGNode to its BasicBlock + // if (nullptr != bb) + // { + // bb->addICFGNode(icfgNode); + // } + // else + // { + // SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + // } std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; if (!svfStmtIds.empty()) @@ -3391,11 +3436,11 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); // parse CallICFGNode svfType - std::string svfTypeName = cJSON_GetObjectItem(properties, "svf_type")->valuestring; - const SVFType* type = pag->getSVFType(svfTypeName); + int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; + const SVFType* type = pag->getSVFType(svfTypeId); if (nullptr == type) { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeName << "\n"; + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeId << "\n"; } // parse CallICFGNode calledFunObjVar @@ -3448,6 +3493,20 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* // create CallICFGNode Instance icfgNode = new CallICFGNode(id, bb, type, funObjVar, calledFunc, retICFGNode, is_vararg, is_vir_call_inst, virtualFunIdx, vtabPtr, fun_name_of_v_call); + + int indFunPtrId = cJSON_GetObjectItem(properties, "ind_fun_ptr_var_id")->valueint; + if (indFunPtrId != -1) + { + SVFVar* indFunPtr = pag->getGNode(indFunPtrId); + if (nullptr != indFunPtr) + { + icfgNode->setIndFunPtr(indFunPtr); + } + else + { + SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching Indirect Function Pointer Var found for id: " << indFunPtrId << "\n"; + } + } // parse CallICFGNode APNodes std::string ap_nodes = cJSON_GetObjectItem(properties, "ap_nodes")->valuestring; @@ -3476,15 +3535,15 @@ ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* retICFGNode->addCallBlockNodeFromDB(icfgNode); } - // add this ICFGNode to its BasicBlock - if (nullptr != bb) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - } + // // add this ICFGNode to its BasicBlock + // if (nullptr != bb) + // { + // bb->addICFGNode(icfgNode); + // } + // else + // { + // SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; + // } std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; if (!svfStmtIds.empty()) @@ -3773,6 +3832,12 @@ CallGraphNode* GraphDBClient::parseCallGraphNodeFromDB(const cJSON* node) // create callGraph node instance cgNode = new CallGraphNode(id, funObjVar); + std::string sourceLocation = cJSON_GetObjectItem(properties, "source_loc")->valuestring; + if ( !sourceLocation.empty() ) + { + cgNode->setSourceLoc(sourceLocation); + } + return cgNode; } @@ -3792,7 +3857,6 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* int csid = cJSON_GetObjectItem(properties,"csid")->valueint; std::string direct_call_set = cJSON_GetObjectItem(properties,"direct_call_set")->valuestring; std::string indirect_call_set = cJSON_GetObjectItem(properties, "indirect_call_set")->valuestring; - int kind = cJSON_GetObjectItem(properties, "kind")->valueint; CallGraphNode* srcNode = callGraph->getGNode(src_id); @@ -3819,7 +3883,6 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(directCallId)); callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addDirectCallSite(node); - pag->addCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); } } @@ -3834,7 +3897,6 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* callGraph->numOfResolvedIndCallEdge++; callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addInDirectCallSite(node); - pag->addCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); } } diff --git a/svf/lib/SVFIR/SVFIR.cpp b/svf/lib/SVFIR/SVFIR.cpp index abe170729..67d3a483b 100644 --- a/svf/lib/SVFIR/SVFIR.cpp +++ b/svf/lib/SVFIR/SVFIR.cpp @@ -529,6 +529,7 @@ NodeID SVFIR::addGepValNode(NodeID curInst,const ValVar* baseVar, const AccessPa && "this node should not be created before"); GepValObjMap[curInst][std::make_pair(base, ap)] = i; GepValVar *node = new GepValVar(baseVar, i, ap, type, icn); + node->setLLVMVarInstID(curInst); return addValNode(node); } diff --git a/svf/lib/SVFIR/SVFStatements.cpp b/svf/lib/SVFIR/SVFStatements.cpp index 4fcbe13f5..5295ad701 100644 --- a/svf/lib/SVFIR/SVFStatements.cpp +++ b/svf/lib/SVFIR/SVFStatements.cpp @@ -563,9 +563,11 @@ std::string GepStmt::toDBString() const if (nullptr != getAccessPath().gepSrcPointeeType()) { - accessPathStr << ", ap_gep_pointee_type_name:'" - << getAccessPath().gepSrcPointeeType()->toString() - << "'"; + accessPathStr << ", ap_gep_pointee_type_id:"<< getAccessPath().gepSrcPointeeType()->getId(); + } + else + { + accessPathStr << ", ap_gep_pointee_type_id:-1"; } if (!getAccessPath().getIdxOperandPairVec().empty()) { @@ -870,4 +872,4 @@ std::string AssignStmt::toDBString() const " CREATE (n)-[r:AssignStmt{" + generateAssignStmtFieldsStmt() + ", kind:" + std::to_string(getEdgeKind()) + "}]->(m)"; return queryStatement; -} +} \ No newline at end of file diff --git a/svf/lib/SVFIR/SVFVariables.cpp b/svf/lib/SVFIR/SVFVariables.cpp index a81975977..fe6cefd4e 100644 --- a/svf/lib/SVFIR/SVFVariables.cpp +++ b/svf/lib/SVFIR/SVFVariables.cpp @@ -534,10 +534,10 @@ std::string SVFVar::getSVFVarNodeFieldsStmt() const { std::string fieldsStr = ""; fieldsStr += "id: " + std::to_string(getId()) + - ", svf_type_name:'"+getType()->toString() + - "', in_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getInEdgeKindToSetMap()) + + ", svf_type_id:"+ std::to_string(getType()->getId()) + + ", in_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getInEdgeKindToSetMap()) + "', out_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getOutEdgeKindToSetMap()) + - "'"; + "'" + sourceLocToDBString(); return fieldsStr; } @@ -681,7 +681,11 @@ std::string GepValVar::toDBString()const if (nullptr != getAccessPath().gepSrcPointeeType()) { - accessPathFieldsStr << ", ap_gep_pointee_type_name:'"<toString()<<"'"; + accessPathFieldsStr << ", ap_gep_pointee_type_id:"<getId(); + } + else + { + accessPathFieldsStr << ", ap_gep_pointee_type_id:-1"; } if (!getAccessPath().getIdxOperandPairVec().empty()) { @@ -691,8 +695,9 @@ std::string GepValVar::toDBString()const getValVarNodeFieldsStmt() + ", kind:" + std::to_string(getNodeKind()) + ", base_val_id:" + std::to_string(getBaseNode()->getId()) - + ", gep_val_svf_type_name:'"+getType()->toString()+"'" + + ", gep_val_svf_type_id:"+std::to_string(getType()->getId()) + ", ap_fld_idx:"+std::to_string(getConstantFieldIdx()) + + ", llvm_var_inst_id:" + std::to_string(getLLVMVarInstID()) + accessPathFieldsStr.str() + "})"; return queryStatement; @@ -742,7 +747,7 @@ std::string BaseObjVar::getBaseObjVarNodeFieldsStmt() const } fieldsStr += getObjVarNodeFieldsStmt() + icfgIDstr + - ", obj_type_info_type_name:'" + getTypeInfo()->getType()->toString() + "'" + + ", obj_type_info_type_id:" + std::to_string(getTypeInfo()->getType()->getId()) + ", obj_type_info_flags:" + std::to_string(getTypeInfo()->getFlag()) + ", obj_type_info_max_offset_limit:" + std::to_string(getMaxFieldOffsetLimit()) + ", obj_type_info_elem_num:" + std::to_string(getNumOfElements()) + @@ -877,6 +882,15 @@ std::string FunObjVar::toDBString() const { annotationsStr = GraphDBClient::getInstance().serializeAnnotations(annotationsVector); } + std::ostringstream valNameStr; + if (getName().empty()) + { + valNameStr << ",val_name:''"; + } + else + { + valNameStr << ",val_name:'"<toString() + "'" + + ", fun_type_id:" + std::to_string(getFunctionType()->getId()) + ", real_def_fun_node_id:" + std::to_string(getDefFunForMultipleModule()->getId()) // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) + exitBBStr.str() @@ -899,7 +913,7 @@ std::string FunObjVar::toDBString() const + ", bb2_p_dom_level:'" + GraphDBClient::getInstance().extractLabelMap2String(&(getLoopAndDomInfo()->getBBPDomLevel())) + "'" + ", bb2_pi_dom:'" + GraphDBClient::getInstance().extractBBsMap2String(&(getLoopAndDomInfo()->getBB2PIdom())) + "'" + ", func_annotation:'" + annotationsStr + "'" + + valNameStr.str() + "})"; return queryStatement; -} - +} \ No newline at end of file From eb6e9f83ea52155721ea3ac8c2d9d740565dac87 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 1 Sep 2025 19:40:39 +1000 Subject: [PATCH 07/19] refactor: move dbInsertStmt from files to dbClient.h clean clean --- CMakeLists.txt | 6 +- svf-llvm/CMakeLists.txt | 2 +- svf-llvm/include/SVF-LLVM/SVFIRBuilder.h | 4 - svf-llvm/lib/SVFIRBuilder.cpp | 1 + svf-llvm/tools/AE/CMakeLists.txt | 2 +- svf-llvm/tools/CFL/CMakeLists.txt | 2 +- svf-llvm/tools/DDA/CMakeLists.txt | 2 +- svf-llvm/tools/Example/CMakeLists.txt | 2 +- svf-llvm/tools/LLVM2SVF/CMakeLists.txt | 2 +- svf-llvm/tools/MTA/CMakeLists.txt | 2 +- svf-llvm/tools/SABER/CMakeLists.txt | 2 +- svf/include/Graphs/BasicBlockG.h | 3 - svf/include/Graphs/CallGraph.h | 9 +- .../Graphs/DBSchema/CallGraphNodeSchema.json | 6 + svf/include/Graphs/ICFGEdge.h | 6 - svf/include/Graphs/ICFGNode.h | 7 - svf/include/SVFIR/GraphDBClient.h | 166 +++ svf/include/SVFIR/SVFStatements.h | 32 - svf/include/SVFIR/SVFType.h | 55 - svf/include/SVFIR/SVFVariables.h | 35 - svf/lib/Graphs/BasicBlockG.cpp | 24 +- svf/lib/Graphs/CallGraph.cpp | 34 - svf/lib/Graphs/ICFG.cpp | 196 --- svf/lib/SVFIR/GraphDBClient.cpp | 1275 ++++++++++++++++- svf/lib/SVFIR/SVFStatements.cpp | 462 ------ svf/lib/SVFIR/SVFType.cpp | 44 - svf/lib/SVFIR/SVFVariables.cpp | 388 ----- 27 files changed, 1396 insertions(+), 1373 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b5963211b..4a099eeb2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ - cmake_minimum_required(VERSION 3.23) +cmake_minimum_required(VERSION 3.23) # ================================================================================= # SVF project definition @@ -278,6 +278,10 @@ if(EXISTS "${SVF_SOURCE_DIR}/Test-Suite") add_subdirectory(Test-Suite) endif() +# ================================================================================= +# SVF core definitions +# ================================================================================= + # Add the tugraph rpc library to all targets of SVF find_library(LGRAPH_CPP_CLIENT_LIBRARIES lgraph_client_cpp_rpc REQUIRED PATHS /usr/local/lib) add_subdirectory(svf) diff --git a/svf-llvm/CMakeLists.txt b/svf-llvm/CMakeLists.txt index c5cf344c9..657471be7 100644 --- a/svf-llvm/CMakeLists.txt +++ b/svf-llvm/CMakeLists.txt @@ -158,4 +158,4 @@ install( # ================================================================================= # Tools # ================================================================================= -add_subdirectory(tools) \ No newline at end of file +add_subdirectory(tools) diff --git a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h index 5bc20be39..dc79337ff 100644 --- a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h +++ b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h @@ -37,7 +37,6 @@ #include "SVF-LLVM/ICFGBuilder.h" #include "SVF-LLVM/LLVMModule.h" #include "SVF-LLVM/LLVMUtil.h" -#include "SVFIR/GraphDBClient.h" namespace SVF { @@ -212,9 +211,6 @@ class SVFIRBuilder: public llvm::InstVisitor /// connect PAG edges based on callgraph void updateCallGraph(CallGraph* callgraph); - void insertCallGraph2db(const CallGraph* callgraph); - void insertICFG2db(const ICFG* icfg); - protected: /// Handle globals including (global variable and functions) //@{ diff --git a/svf-llvm/lib/SVFIRBuilder.cpp b/svf-llvm/lib/SVFIRBuilder.cpp index 4c72e0308..06b6a3671 100644 --- a/svf-llvm/lib/SVFIRBuilder.cpp +++ b/svf-llvm/lib/SVFIRBuilder.cpp @@ -41,6 +41,7 @@ #include "Graphs/CallGraph.h" #include "Util/Options.h" #include "Util/SVFUtil.h" +#include "SVFIR/GraphDBClient.h" using namespace std; using namespace SVF; diff --git a/svf-llvm/tools/AE/CMakeLists.txt b/svf-llvm/tools/AE/CMakeLists.txt index 1dd0dcf5f..883e4d7a2 100644 --- a/svf-llvm/tools/AE/CMakeLists.txt +++ b/svf-llvm/tools/AE/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(ae ae.cpp) \ No newline at end of file +add_llvm_executable(ae ae.cpp) diff --git a/svf-llvm/tools/CFL/CMakeLists.txt b/svf-llvm/tools/CFL/CMakeLists.txt index bcd4567c3..28bf83bab 100644 --- a/svf-llvm/tools/CFL/CMakeLists.txt +++ b/svf-llvm/tools/CFL/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(cfl cfl.cpp) \ No newline at end of file +add_llvm_executable(cfl cfl.cpp) diff --git a/svf-llvm/tools/DDA/CMakeLists.txt b/svf-llvm/tools/DDA/CMakeLists.txt index 499f7395b..06ca6c2bd 100644 --- a/svf-llvm/tools/DDA/CMakeLists.txt +++ b/svf-llvm/tools/DDA/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(dvf dda.cpp) \ No newline at end of file +add_llvm_executable(dvf dda.cpp) diff --git a/svf-llvm/tools/Example/CMakeLists.txt b/svf-llvm/tools/Example/CMakeLists.txt index ee114a71d..6e5b3e538 100644 --- a/svf-llvm/tools/Example/CMakeLists.txt +++ b/svf-llvm/tools/Example/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(svf-ex svf-ex.cpp) \ No newline at end of file +add_llvm_executable(svf-ex svf-ex.cpp) diff --git a/svf-llvm/tools/LLVM2SVF/CMakeLists.txt b/svf-llvm/tools/LLVM2SVF/CMakeLists.txt index 21ad95955..c853b19e1 100644 --- a/svf-llvm/tools/LLVM2SVF/CMakeLists.txt +++ b/svf-llvm/tools/LLVM2SVF/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(llvm2svf llvm2svf.cpp) \ No newline at end of file +add_llvm_executable(llvm2svf llvm2svf.cpp) diff --git a/svf-llvm/tools/MTA/CMakeLists.txt b/svf-llvm/tools/MTA/CMakeLists.txt index 24a8c673b..0810407bf 100644 --- a/svf-llvm/tools/MTA/CMakeLists.txt +++ b/svf-llvm/tools/MTA/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(mta mta.cpp) \ No newline at end of file +add_llvm_executable(mta mta.cpp) diff --git a/svf-llvm/tools/SABER/CMakeLists.txt b/svf-llvm/tools/SABER/CMakeLists.txt index 76260fecf..3bae7a7f4 100644 --- a/svf-llvm/tools/SABER/CMakeLists.txt +++ b/svf-llvm/tools/SABER/CMakeLists.txt @@ -1 +1 @@ -add_llvm_executable(saber saber.cpp) \ No newline at end of file +add_llvm_executable(saber saber.cpp) diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index b6a1213b4..cab183db8 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -64,7 +64,6 @@ class BasicBlockEdge: public GenericBasicBlockEdgeTy virtual const std::string toString() const; - std::string toDBString() const; }; @@ -295,8 +294,6 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy return predBBs; } - std::string toDBString() const; - }; diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index cb7f87db4..1ac0f8a65 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -165,7 +165,6 @@ class CallGraphEdge : public GenericPTACallGraphEdgeTy typedef GenericNode::GEdgeSetTy CallGraphEdgeSet; - std::string toDBString() const; }; class FunObjVar; @@ -226,13 +225,10 @@ class CallGraphNode : public GenericPTACallGraphNodeTy return node->getNodeKind() == CallNodeKd; } - std::string toDBString() const; - - std::string sourceLocToDBString() const { std::string sourceLoc = ""; - if (getSourceLoc().empty() == false) + if (!getSourceLoc().empty()) { sourceLoc = ", source_loc: '" + getSourceLoc() + "'"; } @@ -328,6 +324,8 @@ class CallGraph : public GenericPTACallGraphTy edge->getSrcNode()->addOutgoingEdge(edge); } + /// add direct call graph edge from database [only used this function when loading cgEdges from db results] + void addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); public: /// Constructor CallGraph(CGEK k = NormCallGraph); @@ -384,7 +382,6 @@ class CallGraph : public GenericPTACallGraphTy /// Add direct call edges void addDirectCallGraphEdge(const CallICFGNode* call, const FunObjVar* callerFun, const FunObjVar* calleeFun); - void addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); void addCallGraphNode(const FunObjVar* fun); diff --git a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json index d8a227d4e..78ba5e94f 100644 --- a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json +++ b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json @@ -22,6 +22,12 @@ "type":"STRING", "optional":false, "index":false + }, + { + "name":"fun_name", + "type":"STRING", + "optional":false, + "index":false } ] } diff --git a/svf/include/Graphs/ICFGEdge.h b/svf/include/Graphs/ICFGEdge.h index eed3c13a0..539eac8f8 100644 --- a/svf/include/Graphs/ICFGEdge.h +++ b/svf/include/Graphs/ICFGEdge.h @@ -171,8 +171,6 @@ class IntraCFGEdge : public ICFGEdge { branchCondVal = bVal; } - - std::string toDBString() const; }; /*! @@ -222,8 +220,6 @@ class CallCFGEdge : public ICFGEdge } //@} virtual const std::string toString() const; - - std::string toDBString() const; }; /*! @@ -272,9 +268,7 @@ class RetCFGEdge : public ICFGEdge //@} virtual const std::string toString() const; - std::string toDBString() const; }; - } // End namespace SVF #endif /* ICFGEdge_H_ */ diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index 79e343ee8..b810eed45 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -198,7 +198,6 @@ class GlobalICFGNode : public ICFGNode return "Global ICFGNode"; } - std::string toDBString() const; }; /*! @@ -251,7 +250,6 @@ class IntraICFGNode : public ICFGNode return isRet; } - std::string toDBString() const; }; class InterICFGNode : public ICFGNode @@ -285,7 +283,6 @@ class InterICFGNode : public ICFGNode return isInterICFGNodeKind(node->getNodeKind()); } - std::string toDBString() const; //@} }; @@ -366,7 +363,6 @@ class FunEntryICFGNode : public InterICFGNode const std::string getSourceLoc() const override; - std::string toDBString() const; }; /*! @@ -440,7 +436,6 @@ class FunExitICFGNode : public InterICFGNode const std::string getSourceLoc() const override; - std::string toDBString() const; }; /*! @@ -630,7 +625,6 @@ class CallICFGNode : public InterICFGNode return "CallICFGNode: " + ICFGNode::getSourceLoc(); } - std::string toDBString() const; inline void setIndFunPtr(const SVFVar* indFun) { @@ -730,7 +724,6 @@ class RetICFGNode : public InterICFGNode return "RetICFGNode: " + ICFGNode::getSourceLoc(); } - std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h index 4885ff73d..536c6138e 100644 --- a/svf/include/SVFIR/GraphDBClient.h +++ b/svf/include/SVFIR/GraphDBClient.h @@ -167,6 +167,172 @@ class GraphDBClient void readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag); void parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap); void parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes); + + /// BasicBlockGraph toDBString() + const std::string bb2DBString(const SVFBasicBlock* bb); + const std::string bbEdge2DBString(const BasicBlockEdge* edge); + + /// CallGraph toDBString() + const std::string callGraphNode2DBString(const CallGraphNode* node); + const std::string callGraphEdge2DBString(const CallGraphEdge* edge); + + + /// ICFG toDBString() + const std::string intraCFGEdge2DBString(const IntraCFGEdge* edge); + const std::string callCFGEdge2DBString(const CallCFGEdge* edge); + const std::string retCFGEdge2DBString(const RetCFGEdge* edge); + const std::string globalICFGNode2DBString(const GlobalICFGNode* node); + const std::string intraICFGNode2DBString(const IntraICFGNode* node); + const std::string interICFGNode2DBString(const InterICFGNode* node); + const std::string funEntryICFGNode2DBString(const FunEntryICFGNode* node); + const std::string funExitICFGNode2DBString(const FunExitICFGNode* node); + const std::string retICFGNode2DBString(const RetICFGNode* node); + const std::string callICFGNode2DBString(const CallICFGNode* node); + + /// SVFType toDBString() + const std::string stInfo2DBString(const StInfo* stinfo); + const std::string SVFPointerType2DBString(const SVFPointerType* type); + const std::string SVFArrayType2DBString(const SVFArrayType* type); + const std::string SVFIntegerType2DBString(const SVFIntegerType* type); + const std::string SVFFunctionType2DBString(const SVFFunctionType* type); + const std::string SVFStructType2DBString(const SVFStructType* type); + const std::string SVFOtherType2DBString(const SVFOtherType* type); + + /// PAG toDBString() + const std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* stmt); + const std::string SVFStmt2DBString(const SVFStmt* stmt); + const std::string AssignStmt2DBString(const AssignStmt* stmt); + const std::string AddrStmt2DBString(const AddrStmt* stmt); + const std::string CopyStmt2DBString(const CopyStmt* stmt); + const std::string StoreStmt2DBString(const StoreStmt* stmt); + const std::string LoadStmt2DBString(const LoadStmt* stmt); + const std::string GepStmt2DBString(const GepStmt* stmt); + const std::string CallPE2DBString(const CallPE* stmt); + const std::string RetPE2DBString(const RetPE* stmt); + const std::string MultiOpndStmt2DBString(const MultiOpndStmt* stmt); + const std::string PhiStmt2DBString(const PhiStmt* stmt); + const std::string SelectStmt2DBString(const SelectStmt* stmt); + const std::string CmpStmt2DBString(const CmpStmt* stmt); + const std::string BinaryOPStmt2DBString(const BinaryOPStmt* stmt); + const std::string UnaryOPStmt2DBString(const UnaryOPStmt* stmt); + const std::string BranchStmt2DBString(const BranchStmt* stmt); + const std::string TDForkPE2DBString(const TDForkPE* stmt); + const std::string TDJoinPE2DBString(const TDJoinPE* stmt); + const std::string generateAssignStmtFieldsStmt(const AssignStmt* stmt) + { + return generateSVFStmtEdgeFieldsStmt(stmt); + } + const std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* stmt) + { + std::string stmtStr = generateSVFStmtEdgeFieldsStmt(stmt); + if (!stmt->getOpndVars().empty()) + { + stmtStr += ", op_var_node_ids:'" + extractNodesIds(stmt->getOpndVars())+"'"; + } + else + { + stmtStr += ", op_var_node_ids:''"; + } + return stmtStr; + } + + const std::string valVar2DBString(const ValVar* var); + const std::string objVar2DBString(const ObjVar* var); + const std::string argValVar2DBString(const ArgValVar* var); + const std::string gepValVar2DBString(const GepValVar* var); + const std::string baseObjVar2DBString(const BaseObjVar* var); + const std::string gepObjVar2DBString(const GepObjVar* var); + const std::string heapObjVar2DBString(const HeapObjVar* var); + const std::string stackObjVar2DBString(const StackObjVar* var); + const std::string funObjVar2DBString(const FunObjVar* var); + const std::string funValVar2DBString(const FunValVar* var); + const std::string globalValVar2DBString(const GlobalValVar* var); + const std::string constAggValVar2DBString(const ConstAggValVar* var); + const std::string constDataValVar2DBString(const ConstDataValVar* var); + const std::string blackHoleValVar2DBString(const BlackHoleValVar* var); + const std::string constFPValVar2DBString(const ConstFPValVar* var); + const std::string constIntValVar2DBString(const ConstIntValVar* var); + const std::string constNullPtrValVar2DBString(const ConstNullPtrValVar* var); + const std::string globalObjVar2DBString(const GlobalObjVar* var); + const std::string constAggObjVar2DBString(const ConstAggObjVar* var); + const std::string constDataObjVar2DBString(const ConstDataObjVar* var); + const std::string constFPObjVar2DBString(const ConstFPObjVar* var); + const std::string constIntObjVar2DBString(const ConstIntObjVar* var); + const std::string constNullPtrObjVar2DBString(const ConstNullPtrObjVar* var); + const std::string retValPN2DBString(const RetValPN* var); + const std::string varArgValPN2DBString(const VarArgValPN* var); + const std::string dummyValVar2DBString(const DummyValVar* var); + const std::string dummyObjVar2DBString(const DummyObjVar* var); + const std::string getSVFVarNodeFieldsStmt(const SVFVar* var) + { + std::string fieldsStr = ""; + fieldsStr += "id: " + std::to_string(var->getId()) + + ", svf_type_id:"+ std::to_string(var->getType()->getId()) + + ", in_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(var->getInEdgeKindToSetMap()) + + "', out_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(var->getOutEdgeKindToSetMap()) + + "'" + var->sourceLocToDBString(); + return fieldsStr; + } + + const std::string getValVarNodeFieldsStmt(const ValVar* var) + { + std::string fieldsStr = getSVFVarNodeFieldsStmt(var); + if ( nullptr != var->getICFGNode()) + { + fieldsStr += ", icfg_node_id:" + std::to_string(var->getICFGNode()->getId()); + } + else + { + fieldsStr += ", icfg_node_id:-1"; + } + return fieldsStr; + } + + const std::string getObjVarNodeFieldsStmt(const ObjVar* var) + { + return getSVFVarNodeFieldsStmt(var); + } + + const std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* var) + { + std::string fieldsStr; + std::string icfgIDstr = ""; + if (nullptr != var->getICFGNode()) + { + icfgIDstr = + ", icfg_node_id:" + std::to_string(var->getICFGNode()->getId()); + } + else + { + icfgIDstr = ", icfg_node_id:-1"; + } + std::string objTypeInfo_byteSize_str = ""; + if (var->isConstantByteSize()) + { + objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + + std::to_string(var->getByteSizeOfObj()); + } + fieldsStr += getObjVarNodeFieldsStmt(var) + icfgIDstr + ", obj_type_info_type_id:" + + std::to_string(var->getTypeInfo()->getType()->getId()) + + ", obj_type_info_flags:" + + std::to_string(var->getTypeInfo()->getFlag()) + + ", obj_type_info_max_offset_limit:" + + std::to_string(var->getMaxFieldOffsetLimit()) + + ", obj_type_info_elem_num:" + std::to_string(var->getNumOfElements()) + + objTypeInfo_byteSize_str; + return fieldsStr; + } + + const std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* var) + { + return getBaseObjVarNodeFieldsStmt(var); + } + + const std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* var) + { + return getValVarNodeFieldsStmt(var); + } + std::string parseNodeSourceLocation(cJSON* node) const { cJSON* data = cJSON_GetObjectItem(node, "node"); diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index 29d6ceb4e..03600af76 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -286,10 +286,6 @@ class SVFStmt : public GenericPAGEdgeTy return &multiOpndLabelCounter; } - std::string generateSVFStmtEdgeFieldsStmt() const; - - std::string toDBString() const; - }; /* @@ -373,13 +369,6 @@ class AssignStmt : public SVFStmt } virtual const std::string toString() const = 0; - - std::string generateAssignStmtFieldsStmt() const - { - return generateSVFStmtEdgeFieldsStmt(); - } - - std::string toDBString() const; }; /*! @@ -431,8 +420,6 @@ class AddrStmt: public AssignStmt return arrSize; } - std::string toDBString() const; - }; /*! @@ -522,7 +509,6 @@ class CopyStmt: public AssignStmt virtual const std::string toString() const override; - std::string toDBString() const; private: u32_t copyKind; }; @@ -563,7 +549,6 @@ class StoreStmt: public AssignStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -601,8 +586,6 @@ class LoadStmt: public AssignStmt LoadStmt(SVFVar* s, SVFVar* d) : AssignStmt(s, d, SVFStmt::Load) {} virtual const std::string toString() const override; - - std::string toDBString() const; }; /*! @@ -689,7 +672,6 @@ class GepStmt: public AssignStmt virtual const std::string toString() const; - std::string toDBString() const; }; @@ -754,7 +736,6 @@ class CallPE: public AssignStmt //@} virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -818,7 +799,6 @@ class RetPE: public AssignStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /* @@ -904,10 +884,6 @@ class MultiOpndStmt : public SVFStmt { return opVars.end(); } - - std::string generateMultiOpndStmtEdgeFieldsStmt() const; - - std::string toDBString() const; //@} }; @@ -992,7 +968,6 @@ class PhiStmt: public MultiOpndStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -1050,7 +1025,6 @@ class SelectStmt: public MultiOpndStmt return getOpVar(1); } - std::string toDBString() const; }; /*! @@ -1138,7 +1112,6 @@ class CmpStmt: public MultiOpndStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -1210,7 +1183,6 @@ class BinaryOPStmt: public MultiOpndStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -1280,7 +1252,6 @@ class UnaryOPStmt: public SVFStmt virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -1373,7 +1344,6 @@ BranchStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, SuccAnd //@} virtual const std::string toString() const override; - std::string toDBString() const; }; /*! @@ -1417,7 +1387,6 @@ class TDForkPE: public CallPE virtual const std::string toString() const; - std::string toDBString() const; }; /*! @@ -1462,7 +1431,6 @@ class TDJoinPE: public RetPE virtual const std::string toString() const; - std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index 9e03d78da..272aa9136 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -173,7 +173,6 @@ class StInfo return stride; } - std::string toDBString() const; }; class SVFType @@ -328,17 +327,6 @@ class SVFPointerType : public SVFType void print(std::ostream& os) const override; - std::string toDBString() const - { - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFPointerType {id:" + std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + "})"; - return queryStatement; - } }; class SVFIntegerType : public SVFType @@ -375,19 +363,6 @@ class SVFIntegerType : public SVFType { return signAndWidth < 0; } - - std::string toDBString() const - { - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFIntegerType {id:" + std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + - ", single_and_width:" + std::to_string(getSignAndWidth()) + "})"; - return queryStatement; - } }; class SVFFunctionType : public SVFType @@ -440,7 +415,6 @@ class SVFFunctionType : public SVFType void print(std::ostream& os) const override; - std::string toDBString() const; }; class SVFStructType : public SVFType @@ -495,7 +469,6 @@ class SVFStructType : public SVFType fields.push_back(type); } - std::string toDBString() const; }; class SVFArrayType : public SVFType @@ -543,21 +516,6 @@ class SVFArrayType : public SVFType return numOfElement; } - std::string toDBString() const - { - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFArrayType {id:" +std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", stinfo_node_id:" + std::to_string(getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + - ", num_of_element:" + std::to_string(getNumOfElement()) + - ", type_of_element_node_type_id:" + std::to_string(getTypeOfElement()->getId()) + "})"; - return queryStatement; - } - }; @@ -596,19 +554,6 @@ class SVFOtherType : public SVFType } void print(std::ostream& os) const override; - - std::string toDBString() const - { - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFOtherType {id:" + std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + - ", repr:'" + getRepr() + "'})"; - return queryStatement; - } }; // TODO: be explicit that this is a pair of 32-bit unsigneds? diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index f9b1cb4f5..cb61ca36f 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -263,7 +263,6 @@ class SVFVar : public GenericPAGNodeTy return o; } - std::string getSVFVarNodeFieldsStmt() const; }; @@ -339,7 +338,6 @@ class ValVar: public SVFVar std::string getValVarNodeFieldsStmt() const; - std::string toDBString() const; }; /* @@ -392,7 +390,6 @@ class ObjVar: public SVFVar std::string getObjVarNodeFieldsStmt() const; - std::string toDBString() const; }; @@ -472,7 +469,6 @@ class ArgValVar: public ValVar virtual const std::string toString() const; - std::string toDBString() const; }; @@ -587,7 +583,6 @@ class GepValVar: public ValVar return base->isConstDataOrAggData(); } - std::string toDBString() const; /// Get the LLVM variable ID associated with this GepValVar inline NodeID getLLVMVarInstID() const { @@ -822,10 +817,6 @@ class BaseObjVar : public ObjVar virtual const FunObjVar* getFunction() const; - std::string getBaseObjVarNodeFieldsStmt() const; - - std::string toDBString() const; - }; @@ -932,7 +923,6 @@ class GepObjVar: public ObjVar return base->isPointer(); } - std::string toDBString() const; }; @@ -996,7 +986,6 @@ class HeapObjVar: public BaseObjVar virtual const std::string toString() const; - std::string toDBString() const; }; @@ -1062,7 +1051,6 @@ class StackObjVar: public BaseObjVar virtual const std::string toString() const; - std::string toDBString() const; }; @@ -1368,7 +1356,6 @@ class FunObjVar : public BaseObjVar virtual const std::string toString() const; - std::string toDBString() const; }; class FunValVar : public ValVar { @@ -1427,7 +1414,6 @@ class FunValVar : public ValVar } virtual const std::string toString() const; - std::string toDBString() const; }; @@ -1475,7 +1461,6 @@ class GlobalValVar : public ValVar virtual const std::string toString() const; - std::string toDBString() const; }; class ConstAggValVar: public ValVar @@ -1531,7 +1516,6 @@ class ConstAggValVar: public ValVar virtual const std::string toString() const; - std::string toDBString() const; }; @@ -1594,9 +1578,6 @@ class ConstDataValVar : public ValVar } virtual const std::string toString() const; - - std::string getConstDataValVarNodeFieldsStmt() const; - std::string toDBString() const; }; class BlackHoleValVar : public ConstDataValVar @@ -1648,7 +1629,6 @@ class BlackHoleValVar : public ConstDataValVar return "BlackHoleValVar"; } - std::string toDBString() const; }; class ConstFPValVar : public ConstDataValVar @@ -1708,7 +1688,6 @@ class ConstFPValVar : public ConstDataValVar virtual const std::string toString() const; - std::string toDBString() const; }; class ConstIntValVar : public ConstDataValVar @@ -1776,7 +1755,6 @@ class ConstIntValVar : public ConstDataValVar } virtual const std::string toString() const; - std::string toDBString() const; }; class ConstNullPtrValVar : public ConstDataValVar @@ -1832,7 +1810,6 @@ class ConstNullPtrValVar : public ConstDataValVar virtual const std::string toString() const; - std::string toDBString() const; }; class GlobalObjVar : public BaseObjVar @@ -1889,7 +1866,6 @@ class GlobalObjVar : public BaseObjVar virtual const std::string toString() const; - std::string toDBString() const; }; class ConstAggObjVar : public BaseObjVar @@ -1950,7 +1926,6 @@ class ConstAggObjVar : public BaseObjVar } virtual const std::string toString() const; - std::string toDBString() const; }; class ConstDataObjVar : public BaseObjVar @@ -2014,9 +1989,6 @@ class ConstDataObjVar : public BaseObjVar } virtual const std::string toString() const; - - std::string getConstDataObjVarNodeFieldsStmt() const; - std::string toDBString() const; }; class ConstFPObjVar : public ConstDataObjVar @@ -2087,7 +2059,6 @@ class ConstFPObjVar : public ConstDataObjVar virtual const std::string toString() const; - std::string toDBString() const; }; class ConstIntObjVar : public ConstDataObjVar @@ -2164,7 +2135,6 @@ class ConstIntObjVar : public ConstDataObjVar virtual const std::string toString() const; - std::string toDBString() const; }; class ConstNullPtrObjVar : public ConstDataObjVar @@ -2226,7 +2196,6 @@ class ConstNullPtrObjVar : public ConstDataObjVar } virtual const std::string toString() const; - std::string toDBString() const; }; /* * Unique Return node of a procedure @@ -2289,7 +2258,6 @@ class RetValPN : public ValVar virtual const std::string toString() const; - std::string toDBString() const; }; /* @@ -2352,7 +2320,6 @@ class VarArgValPN : public ValVar } virtual const std::string toString() const; - std::string toDBString() const; }; /* @@ -2409,7 +2376,6 @@ class DummyValVar: public ValVar virtual const std::string toString() const; - std::string toDBString() const; }; /* @@ -2476,7 +2442,6 @@ class DummyObjVar: public BaseObjVar virtual const std::string toString() const; - std::string toDBString() const; }; } // End namespace SVF diff --git a/svf/lib/Graphs/BasicBlockG.cpp b/svf/lib/Graphs/BasicBlockG.cpp index 8c5a63eb4..30ddc7f9a 100644 --- a/svf/lib/Graphs/BasicBlockG.cpp +++ b/svf/lib/Graphs/BasicBlockG.cpp @@ -22,26 +22,4 @@ const std::string SVFBasicBlock::toString() const } rawstr << "\n----------------------------------------\n"; return rawstr.str(); -} - -std::string SVFBasicBlock::toDBString() const -{ - const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(getId())+":" + std::to_string(getFunction()->getId()) + "'" + - ", fun_obj_var_id: " + std::to_string(getFunction()->getId()) + - ", bb_name:'" + getName() +"'" + - ", sscc_bb_ids:'" + GraphDBClient::getInstance().extractNodesIds(getSuccBBs()) + "'" + - ", pred_bb_ids:'" + GraphDBClient::getInstance().extractNodesIds(getPredBBs()) + "'" + - ", all_icfg_nodes_ids:'" + GraphDBClient::getInstance().extractNodesIds(getICFGNodeList()) + "'" + - + "})"; - return queryStatement; -} - -std::string BasicBlockEdge::toDBString() const -{ - const std::string queryStatement = - "MATCH (n:SVFBasicBlock {id:'"+std::to_string(getSrcID())+":"+std::to_string(getSrcNode()->getFunction()->getId())+"'}), (m:SVFBasicBlock{id:'"+std::to_string(getDstID())+":"+std::to_string(getDstNode()->getFunction()->getId())+ - "'}) WHERE n.id = '" +std::to_string(getSrcID())+":" + std::to_string(getSrcNode()->getFunction()->getId())+ "'"+ - " AND m.id = '" +std::to_string(getDstID())+":" + std::to_string(getDstNode()->getFunction()->getId())+ "'"+ - " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; - return queryStatement; -} +} \ No newline at end of file diff --git a/svf/lib/Graphs/CallGraph.cpp b/svf/lib/Graphs/CallGraph.cpp index 490ae41b3..75c936a1a 100644 --- a/svf/lib/Graphs/CallGraph.cpp +++ b/svf/lib/Graphs/CallGraph.cpp @@ -65,40 +65,6 @@ void CallGraphEdge::addInDirectCallSite(const CallICFGNode* call) } //@} -std::string CallGraphEdge::toDBString() const -{ - std::string indirectCallIds = ""; - Set indirectCall = getIndirectCalls(); - if (indirectCall.size() > 0) - { - indirectCallIds = GraphDBClient::getInstance().extractNodesIds(indirectCall); - } - - std::string directCallIds = ""; - Set directCall = getDirectCalls(); - if (directCall.size() > 0) - { - directCallIds = GraphDBClient::getInstance().extractNodesIds(directCall); - } - - const std::string queryStatement = - "MATCH (n:CallGraphNode{id:"+std::to_string(getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(getDstNode()->getId()) + "}) WHERE n.id = " + - std::to_string(getSrcNode()->getId()) + - " AND m.id = " + std::to_string(getDstNode()->getId()) + - " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(getCallSiteID()) + - ", kind:" + std::to_string(getEdgeKind()) + - ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + - indirectCallIds + "'}]->(m)"; - return queryStatement; -} - -std::string CallGraphNode::toDBString() const -{ - const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(getId()) + - ", fun_obj_var_id: " + std::to_string(getFunction()->getId()) + sourceLocToDBString() + "})"; - return queryStatement; -} - const std::string CallGraphEdge::toString() const { std::string str; diff --git a/svf/lib/Graphs/ICFG.cpp b/svf/lib/Graphs/ICFG.cpp index 7dc80b32d..f6cfec7b8 100644 --- a/svf/lib/Graphs/ICFG.cpp +++ b/svf/lib/Graphs/ICFG.cpp @@ -47,18 +47,6 @@ FunEntryICFGNode::FunEntryICFGNode(NodeID id, const FunObjVar* f) : InterICFGNod } } -std::string FunEntryICFGNode::toDBString() const -{ - const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(getBB()->getId()) + - ", fp_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getFormalParms()) +"'"+ - sourceLocToDBString() + "})"; - return queryStatement; -} - FunExitICFGNode::FunExitICFGNode(NodeID id, const FunObjVar* f) : InterICFGNode(id, FunExitBlock), formalRet(nullptr) { @@ -70,24 +58,6 @@ FunExitICFGNode::FunExitICFGNode(NodeID id, const FunObjVar* f) } } -std::string FunExitICFGNode::toDBString() const -{ - std::string formalRetId = ""; - if (nullptr == getFormalRet()) - { - formalRetId = ",formal_ret_node_id:-1"; - } else { - formalRetId = ",formal_ret_node_id:" + std::to_string(getFormalRet()->getId()); - } - const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(getBB()->getId()) + - formalRetId + sourceLocToDBString() + "})"; - return queryStatement; -} - const std::string ICFGNode::toString() const { std::string str; @@ -180,64 +150,6 @@ const std::string CallICFGNode::toString() const return rawstr.str(); } -std::string CallICFGNode::toDBString() const -{ - std::string fun_name_of_v_call = ""; - std::string vtab_ptr_node_id = ""; - std::string virtual_fun_idx = ""; - std::string is_vir_call_inst = isVirtualCall() ? "true" : "false"; - std::string virtualFunAppendix = ""; - int indFunPtrId = -1; - if (isIndirectCall()) - { - indFunPtrId = getIndFunPtr()->getId(); - } - if (isVirtualCall()) - { - fun_name_of_v_call = ", fun_name_of_v_call: '"+getFunNameOfVirtualCall()+"'"; - vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(getVtablePtr()->getId()); - virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(getFunIdxInVtable()); - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; - } - else - { - vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; - virtual_fun_idx = ", virtual_fun_idx:-1"; - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; - } - std::string called_fun_obj_var_id = ""; - if (getCalledFunction() != nullptr) - { - called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(getCalledFunction()->getId()); - } - else - { - called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; - } - std::string ret_icfg_node_id = ""; - if (getRetICFGNode() != nullptr) - { - ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(getRetICFGNode()->getId()); - } - else - { - ret_icfg_node_id = ", ret_icfg_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ret_icfg_node_id + - ", bb_id: " + std::to_string(getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", svf_type_id:" + std::to_string(getType()->getId()) + - ", ap_nodes:'" + GraphDBClient::getInstance().extractNodesIds(getActualParms()) +"'" + - called_fun_obj_var_id + - ", is_vararg: " + (isVarArg() ? "true" : "false") + - ", is_vir_call_inst: " + (isVirtualCall() ? "true" : "false") + - ", ind_fun_ptr_var_id:" + std::to_string(indFunPtrId) + - virtualFunAppendix+ sourceLocToDBString() +"})"; - return queryStatement; -} const std::string RetICFGNode::toString() const { @@ -252,26 +164,6 @@ const std::string RetICFGNode::toString() const return rawstr.str(); } -std::string RetICFGNode::toDBString() const -{ - std::string actual_ret_node_id=""; - if (getActualRet() != nullptr) - { - actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(getActualRet()->getId()) ; - } else { - actual_ret_node_id = ", actual_ret_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - actual_ret_node_id+ - ", call_block_node_id: " + std::to_string(getCallICFGNode()->getId()) + - ", bb_id: " + std::to_string(getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(getFun()->getId()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", svf_type_id:" + std::to_string(getType()->getId()) + sourceLocToDBString() + "})"; - return queryStatement; -} - const std::string ICFGEdge::toString() const { std::string str; @@ -292,30 +184,6 @@ const std::string IntraCFGEdge::toString() const return rawstr.str(); } -std::string IntraCFGEdge::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); - std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); - std::string condition = ""; - if (getCondition() != nullptr) - { - condition = - ", condition_var_id:" + std::to_string(getCondition()->getId()) + - ", branch_cond_val:" + std::to_string(getSuccessorCondValue()); - } - else - { - condition = ", condition_var_id:-1, branch_cond_val:-1"; - } - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + - " AND m.id = " + std::to_string(getDstNode()->getId()) + - " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(getEdgeKind()) + - condition + "}]->(m)"; - return queryStatement; -} const std::string CallCFGEdge::toString() const { @@ -326,20 +194,6 @@ const std::string CallCFGEdge::toString() const return rawstr.str(); } -std::string CallCFGEdge::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); - std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + - " AND m.id = " + std::to_string(getDstNode()->getId()) + - " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(getEdgeKind()) + - ", call_pe_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getCallPEs()) + "'}]->(m)"; - return queryStatement; -} - const std::string RetCFGEdge::toString() const { std::string str; @@ -349,28 +203,6 @@ const std::string RetCFGEdge::toString() const return rawstr.str(); } -std::string RetCFGEdge::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getICFGNodeKindString(getSrcNode()); - std::string dstKind = GraphDBClient::getInstance().getICFGNodeKindString(getDstNode()); - std::string ret_pe_id = ""; - if (getRetPE() != nullptr) - { - ret_pe_id = ", ret_pe_id:" + std::to_string(getRetPE()->getEdgeID()); - } - else - { - ret_pe_id = ", ret_pe_id:-1"; - } - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(getSrcNode()->getId()) + - " AND m.id = " + std::to_string(getDstNode()->getId()) + - " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(getEdgeKind()) + - ret_pe_id + "}]->(m)"; - return queryStatement; -} /// Return call ICFGNode at the callsite const CallICFGNode* RetCFGEdge::getCallSite() const @@ -653,34 +485,6 @@ void ICFG::updateCallGraph(CallGraph* callgraph) } } -std::string IntraICFGNode::toDBString() const -{ - const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ", is_return: " + (isRetInst() ? "true" : "false") + - ", fun_obj_var_id:" + std::to_string(getFun()->getId()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(getBB()->getId()) + - sourceLocToDBString() + "})"; - return queryStatement; -} - -std::string InterICFGNode::toDBString() const{ - const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'"+ - sourceLocToDBString() + "})"; - return queryStatement; -} - -std::string GlobalICFGNode::toDBString() const -{ - const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(getId()) + - ", kind: " + std::to_string(getNodeKind()) + - ", pag_edge_ids:'" + GraphDBClient::getInstance().extractEdgesIds(getSVFStmts()) +"'"+ - sourceLocToDBString() + "})"; - return queryStatement; -} /*! * GraphTraits specialization */ diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 2d39b2a40..69da6e400 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -59,15 +59,15 @@ bool GraphDBClient::addICFGEdge2db(lgraph::RpcClient* connection, std::string queryStatement; if(const IntraCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = cfgEdge->toDBString(); + queryStatement = intraCFGEdge2DBString(cfgEdge); } else if (const CallCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = cfgEdge->toDBString(); + queryStatement = callCFGEdge2DBString(cfgEdge); } else if (const RetCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) { - queryStatement = cfgEdge->toDBString(); + queryStatement = retCFGEdge2DBString(cfgEdge); } else { @@ -101,27 +101,27 @@ bool GraphDBClient::addICFGNode2db(lgraph::RpcClient* connection, std::string queryStatement; if(const GlobalICFGNode* globalICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = globalICFGNode->toDBString(); + queryStatement = globalICFGNode2DBString(globalICFGNode); } else if (const IntraICFGNode* intraICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = intraICFGNode->toDBString(); + queryStatement = intraICFGNode2DBString(intraICFGNode); } else if (const FunEntryICFGNode* funEntryICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = funEntryICFGNode->toDBString(); + queryStatement = funEntryICFGNode2DBString(funEntryICFGNode); } else if (const FunExitICFGNode* funExitICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = funExitICFGNode->toDBString(); + queryStatement = funExitICFGNode2DBString(funExitICFGNode); } else if (const CallICFGNode* callICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = callICFGNode->toDBString(); + queryStatement = callICFGNode2DBString(callICFGNode); } else if (const RetICFGNode* retICFGNode = SVFUtil::dyn_cast(node)) { - queryStatement = retICFGNode->toDBString(); + queryStatement = retICFGNode2DBString(retICFGNode); } else { @@ -152,7 +152,7 @@ bool GraphDBClient::addCallGraphNode2db(lgraph::RpcClient* connection, { if (nullptr != connection) { - const std::string queryStatement = node->toDBString(); + const std::string queryStatement = callGraphNode2DBString(node); // SVFUtil::outs()<<"CallGraph Node Insert Query:"<CallCypher(result, queryStatement, dbname); @@ -172,7 +172,7 @@ bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, { if (nullptr != connection) { - const std::string queryStatement = edge->toDBString(); + const std::string queryStatement = callGraphEdge2DBString(edge); // SVFUtil::outs() << "Call Graph Edge Insert Query:" << queryStatement << "\n"; std::string result; bool ret = connection->CallCypher(result, queryStatement, dbname); @@ -399,8 +399,7 @@ void GraphDBClient::insertCallGraph2db(const CallGraph* callGraph) for (const auto& item : *callGraph) { const CallGraphNode* node = item.second; - SVF::GraphDBClient::getInstance().addCallGraphNode2db( - connection, node, "CallGraph"); + addCallGraphNode2db(connection, node, "CallGraph"); for (CallGraphEdge::CallGraphEdgeSet::iterator iter = node->OutEdgeBegin(); iter != node->OutEdgeEnd(); ++iter) @@ -411,7 +410,7 @@ void GraphDBClient::insertCallGraph2db(const CallGraph* callGraph) } for (const auto& edge : edges) { - SVF::GraphDBClient::getInstance().addCallGraphEdge2db(connection, edge, "CallGraph"); + addCallGraphEdge2db(connection, edge, "CallGraph"); } } else { @@ -434,27 +433,27 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co std::string queryStatement; if (const SVFPointerType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFPointerType2DBString(svfType); } else if (const SVFIntegerType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFIntegerType2DBString(svfType); } else if (const SVFFunctionType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFFunctionType2DBString(svfType); } else if (const SVFStructType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFStructType2DBString(svfType); } else if (const SVFArrayType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFArrayType2DBString(svfType); } else if (const SVFOtherType* svfType = SVFUtil::dyn_cast(ty)) { - queryStatement = svfType->toDBString(); + queryStatement = SVFOtherType2DBString(svfType); } else { @@ -477,7 +476,7 @@ void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, co for(const StInfo* stInfo : *stInfos) { // insert stinfo node to db - std::string queryStatement = stInfo->toDBString(); + std::string queryStatement = stInfo2DBString(stInfo); // SVFUtil::outs()<<"StInfo Insert Query:"<CallCypher(result, queryStatement, dbname); @@ -516,7 +515,7 @@ void GraphDBClient::insertBBEdge2db(lgraph::RpcClient* connection, const BasicBl { if (nullptr != connection) { - std::string queryStatement = edge->toDBString(); + std::string queryStatement = bbEdge2DBString(edge); // SVFUtil::outs()<<"BBEdge Insert Query:"<toDBString(); + std::string queryStatement = bb2DBString(node); // SVFUtil::outs()<<"BBNode Insert Query:"<(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = TDForkPE2DBString(svfStmt); } else if(const TDJoinPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = TDJoinPE2DBString(svfStmt); } else if(const CallPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = CallPE2DBString(svfStmt); } else if(const RetPE* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = RetPE2DBString(svfStmt); } else if(const GepStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = GepStmt2DBString(svfStmt); } else if(const LoadStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = LoadStmt2DBString(svfStmt); } else if(const StoreStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = StoreStmt2DBString(svfStmt); } else if(const CopyStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = CopyStmt2DBString(svfStmt); } else if(const AddrStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = AddrStmt2DBString(svfStmt); } else if(const AssignStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = AssignStmt2DBString(svfStmt); } else if(const PhiStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = PhiStmt2DBString(svfStmt); } else if(const SelectStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = SelectStmt2DBString(svfStmt); } else if(const CmpStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = CmpStmt2DBString(svfStmt); } else if(const BinaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = BinaryOPStmt2DBString(svfStmt); } else if(const MultiOpndStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = MultiOpndStmt2DBString(svfStmt); } else if(const UnaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = UnaryOPStmt2DBString(svfStmt); } else if(const BranchStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = BranchStmt2DBString(svfStmt); } else if(const SVFStmt* svfStmt = SVFUtil::dyn_cast(edge)) { - queryStatement = svfStmt->toDBString(); + queryStatement = SVFStmt2DBString(svfStmt); } else { @@ -727,91 +726,91 @@ std::string GraphDBClient::getPAGNodeInsertStmt(const SVFVar* node) std::string queryStatement = ""; if(const ConstNullPtrValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constNullPtrValVar2DBString(svfVar); } else if(const ConstIntValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constIntValVar2DBString(svfVar); } else if(const ConstFPValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constFPValVar2DBString(svfVar); } else if(const BlackHoleValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = blackHoleValVar2DBString(svfVar); } else if(const ConstDataValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constDataValVar2DBString(svfVar); } else if(const RetValPN* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = retValPN2DBString(svfVar); } else if(const VarArgValPN* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = varArgValPN2DBString(svfVar); } else if(const DummyValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = dummyValVar2DBString(svfVar); } else if(const ConstAggValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constAggValVar2DBString(svfVar); } else if(const GlobalValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = globalValVar2DBString(svfVar); } else if(const FunValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = funValVar2DBString(svfVar); } else if(const GepValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = gepValVar2DBString(svfVar); } else if(const ArgValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = argValVar2DBString(svfVar); } else if(const ValVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = valVar2DBString(svfVar); } else if(const ConstNullPtrObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constNullPtrObjVar2DBString(svfVar); } else if(const ConstIntObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement =svfVar->toDBString(); + queryStatement = constIntObjVar2DBString(svfVar); } else if(const ConstFPObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constFPObjVar2DBString(svfVar); } else if(const ConstDataObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constDataObjVar2DBString(svfVar); } else if(const DummyObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = dummyObjVar2DBString(svfVar); } else if(const ConstAggObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = constAggObjVar2DBString(svfVar); } else if(const GlobalObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = globalObjVar2DBString(svfVar); } else if(const FunObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = funObjVar2DBString(svfVar); if ( nullptr != svfVar->getBasicBlockGraph()) { insertBasicBlockGraph2db(svfVar->getBasicBlockGraph()); @@ -819,23 +818,23 @@ std::string GraphDBClient::getPAGNodeInsertStmt(const SVFVar* node) } else if(const StackObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = stackObjVar2DBString(svfVar); } else if(const HeapObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = heapObjVar2DBString(svfVar); } else if(const BaseObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = baseObjVar2DBString(svfVar); } else if(const GepObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = gepObjVar2DBString(svfVar); } else if(const ObjVar* svfVar = SVFUtil::dyn_cast(node)) { - queryStatement = svfVar->toDBString(); + queryStatement = objVar2DBString(svfVar); } else { @@ -3902,4 +3901,1142 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* } return cgEdge; -} \ No newline at end of file +} + +/// BasicBlockGraph insertions query statements +const std::string GraphDBClient::bbEdge2DBString(const BasicBlockEdge* edge) +{ + const std::string queryStatement = + "MATCH (n:SVFBasicBlock {id:'"+std::to_string(edge->getSrcID())+":"+std::to_string(edge->getSrcNode()->getFunction()->getId())+ + "'}), (m:SVFBasicBlock{id:'"+std::to_string(edge->getDstID())+":"+std::to_string(edge->getDstNode()->getFunction()->getId())+ + "'}) WHERE n.id = '" +std::to_string(edge->getSrcID())+":" + std::to_string(edge->getSrcNode()->getFunction()->getId())+ "'"+ + " AND m.id = '" +std::to_string(edge->getDstID())+":" + std::to_string(edge->getDstNode()->getFunction()->getId())+ "'"+ + " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::bb2DBString(const SVFBasicBlock* bb) +{ + const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(bb->getId())+":" + std::to_string(bb->getFunction()->getId()) + "'" + + ", fun_obj_var_id: " + std::to_string(bb->getFunction()->getId()) + + ", bb_name:'" + bb->getName() +"'" + + ", sscc_bb_ids:'" + extractNodesIds(bb->getSuccBBs()) + "'" + + ", pred_bb_ids:'" + extractNodesIds(bb->getPredBBs()) + "'" + + ", all_icfg_nodes_ids:'" + extractNodesIds(bb->getICFGNodeList()) + "'" + + + "})"; + return queryStatement; +} + +/// CallGraph insertions query statements +const std::string GraphDBClient::callGraphNode2DBString(const CallGraphNode* node) +{ + const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(node->getId()) + + ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + + node->sourceLocToDBString() + + ", fun_name:'" + node->getName()+ "'" + "})"; + return queryStatement; +} + +const std::string GraphDBClient::callGraphEdge2DBString(const CallGraphEdge* edge) +{ + std::string indirectCallIds = ""; + Set indirectCall = edge->getIndirectCalls(); + if (indirectCall.size() > 0) + { + indirectCallIds = extractNodesIds(indirectCall); + } + + std::string directCallIds = ""; + Set directCall = edge->getDirectCalls(); + if (directCall.size() > 0) + { + directCallIds = extractNodesIds(directCall); + } + + const std::string queryStatement = + "MATCH (n:CallGraphNode{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(edge->getDstNode()->getId()) + "}) WHERE n.id = " + + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(edge->getCallSiteID()) + + ", kind:" + std::to_string(edge->getEdgeKind()) + + ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + + indirectCallIds + "'}]->(m)"; + return queryStatement; +} + +/// ICFG insertions query statements +const std::string GraphDBClient::intraCFGEdge2DBString(const IntraCFGEdge* edge) +{ + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + std::string condition = ""; + if (edge->getCondition() != nullptr) + { + condition = + ", condition_var_id:" + std::to_string(edge->getCondition()->getId()) + + ", branch_cond_val:" + std::to_string(edge->getSuccessorCondValue()); + } + else + { + condition = ", condition_var_id:-1, branch_cond_val:-1"; + } + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + condition + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::callCFGEdge2DBString(const CallCFGEdge* edge) +{ + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + ", call_pe_ids:'" + extractEdgesIds(edge->getCallPEs()) + "'}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::retCFGEdge2DBString(const RetCFGEdge* edge) +{ + std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); + std::string dstKind = getICFGNodeKindString(edge->getDstNode()); + std::string ret_pe_id = ""; + if (edge->getRetPE() != nullptr) + { + ret_pe_id = ", ret_pe_id:" + std::to_string(edge->getRetPE()->getEdgeID()); + } + else + { + ret_pe_id = ", ret_pe_id:-1"; + } + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + + "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + + " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + + ret_pe_id + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::globalICFGNode2DBString(const GlobalICFGNode* node) +{ + const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'"+ + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::intraICFGNode2DBString(const IntraICFGNode* node) +{ + const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", is_return: " + (node->isRetInst() ? "true" : "false") + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(node->getBB()->getId()) + + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::interICFGNode2DBString(const InterICFGNode* node) +{ + const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'"+ + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::funEntryICFGNode2DBString(const FunEntryICFGNode* node) +{ + const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(node->getBB()->getId()) + + ", fp_nodes:'" + extractNodesIds(node->getFormalParms()) +"'"+ + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::funExitICFGNode2DBString(const FunExitICFGNode* node) +{ + std::string formalRetId = ""; + if (nullptr == node->getFormalRet()) + { + formalRetId = ",formal_ret_node_id:-1"; + } else { + formalRetId = ",formal_ret_node_id:" + std::to_string(node->getFormalRet()->getId()); + } + const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + + ", bb_id:" + std::to_string(node->getBB()->getId()) + + formalRetId + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::retICFGNode2DBString(const RetICFGNode* node) +{ + std::string actual_ret_node_id=""; + if (node->getActualRet() != nullptr) + { + actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(node->getActualRet()->getId()) ; + } else { + actual_ret_node_id = ", actual_ret_node_id: -1"; + } + const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + actual_ret_node_id+ + ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + + ", bb_id: " + std::to_string(node->getBB()->getId()) + + ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + + ", svf_type_id:" + std::to_string(node->getType()->getId()) + node->sourceLocToDBString() + "})"; + return queryStatement; +} + +const std::string GraphDBClient::callICFGNode2DBString(const CallICFGNode* node) +{ + std::string fun_name_of_v_call = ""; + std::string vtab_ptr_node_id = ""; + std::string virtual_fun_idx = ""; + std::string is_vir_call_inst = node->isVirtualCall() ? "true" : "false"; + std::string virtualFunAppendix = ""; + int indFunPtrId = -1; + if (node->isIndirectCall()) + { + indFunPtrId = node->getIndFunPtr()->getId(); + } + if (node->isVirtualCall()) + { + fun_name_of_v_call = ", fun_name_of_v_call: '"+node->getFunNameOfVirtualCall()+"'"; + vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(node->getVtablePtr()->getId()); + virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(node->getFunIdxInVtable()); + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; + } + else + { + vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; + virtual_fun_idx = ", virtual_fun_idx:-1"; + virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; + } + std::string called_fun_obj_var_id = ""; + if (node->getCalledFunction() != nullptr) + { + called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(node->getCalledFunction()->getId()); + } + else + { + called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; + } + std::string ret_icfg_node_id = ""; + if (node->getRetICFGNode() != nullptr) + { + ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()); + } + else + { + ret_icfg_node_id = ", ret_icfg_node_id: -1"; + } + const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(node->getId()) + + ", kind: " + std::to_string(node->getNodeKind()) + + ret_icfg_node_id + + ", bb_id: " + std::to_string(node->getBB()->getId()) + + ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + + ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + + ", svf_type_id:" + std::to_string(node->getType()->getId()) + + ", ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'" + + called_fun_obj_var_id + + ", is_vararg: " + (node->isVarArg() ? "true" : "false") + + ", is_vir_call_inst: " + (node->isVirtualCall() ? "true" : "false") + + ", ind_fun_ptr_var_id:" + std::to_string(indFunPtrId) + + virtualFunAppendix+ node->sourceLocToDBString() +"})"; + return queryStatement; +} + +/// SVFType insertions query statements +const std::string GraphDBClient::stInfo2DBString(const StInfo* stinfo) +{ + const std::string queryStatement ="CREATE (n:StInfo {st_info_id:" + std::to_string(stinfo->getStinfoId()) + + ", fld_idx_vec:'" + extractIdxs(stinfo->getFlattenedFieldIdxVec()) + + "', elem_idx_vec:'" + extractIdxs(stinfo->getFlattenedElemIdxVec()) + + "', finfo_types:'" + extractSVFTypes(stinfo->getFlattenFieldTypes()) + + "', flatten_element_types:'" + extractSVFTypes(stinfo->getFlattenElementTypes()) + + "', fld_idx_2_type_map:'" + extractFldIdx2TypeMap(stinfo->getFldIdx2TypeMap()) + + "', stride:" + std::to_string(stinfo->getStride()) + + ", num_of_flatten_elements:" + std::to_string(stinfo->getNumOfFlattenElements()) + + ", num_of_flatten_fields:" + std::to_string(stinfo->getNumOfFlattenFields()) + "})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFPointerType2DBString(const SVFPointerType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFPointerType {id:" + std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + "})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFArrayType2DBString(const SVFArrayType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFArrayType {id:" +std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", stinfo_node_id:" + std::to_string(type->getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + + ", num_of_element:" + std::to_string(type->getNumOfElement()) + + ", type_of_element_node_type_id:" + std::to_string(type->getTypeOfElement()->getId()) + "})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFIntegerType2DBString(const SVFIntegerType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFIntegerType {id:" + std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + + ", single_and_width:" + std::to_string(type->getSignAndWidth()) + "})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFFunctionType2DBString(const SVFFunctionType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFFunctionType {id:" + std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + + ", params_types_vec:'" + extractSVFTypes(type->getParamTypes()) + + "', ret_ty_node_id:" + std::to_string(type->getReturnType()->getId()) + "})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFStructType2DBString(const SVFStructType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFStructType {id:" + std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", stinfo_node_id:" + std::to_string(type->getTypeInfo()->getStinfoId()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + + ", struct_name:'" + type->getName() + "'" + + ", fields_id_vec:'" + extractSVFTypes(type->getFieldTypes()) + + "'})"; + return queryStatement; +} + +const std::string GraphDBClient::SVFOtherType2DBString(const SVFOtherType* type) +{ + std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; + const std::string queryStatement ="CREATE (n:SVFOtherType {id:" + std::to_string(type->getId()) + + ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + + ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + + ", kind:" + std::to_string(type->getKind()) + + ", is_single_val_ty:" + is_single_val_ty + + ", byte_size:" + std::to_string(type->getByteSize()) + + ", repr:'" + type->getRepr() + "'})"; + return queryStatement; +} + +/// PAG insertions query statements +const std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* stmt) +{ + std::string valueStr = ""; + if (nullptr != stmt->getValue()) + { + valueStr += ", svf_var_node_id:"+ std::to_string(stmt->getValue()->getId()); + } + else + { + valueStr += ", svf_var_node_id:-1"; + } + std::string bb_id_str = ""; + if (nullptr != stmt->getBB()) + { + bb_id_str += ", bb_id:'" + std::to_string(stmt->getBB()->getParent()->getId()) + ":" + std::to_string(stmt->getBB()->getId())+"'"; + } + else + { + bb_id_str += ", bb_id:''"; + } + + std::string icfg_node_id_str = ""; + if (nullptr != stmt->getICFGNode()) + { + icfg_node_id_str += ", icfg_node_id:" + std::to_string(stmt->getICFGNode()->getId()); + } + else + { + icfg_node_id_str += ", icfg_node_id:-1"; + } + + std::string inst2_label_map = ""; + if (nullptr != stmt->getInst2LabelMap() && !stmt->getInst2LabelMap()->empty()) + { + inst2_label_map += ", inst2_label_map:'"+ extractLabelMap2String(stmt->getInst2LabelMap()) +"'"; + } + + std::string var2_label_map = ""; + if (nullptr != stmt->getVar2LabelMap() && !stmt->getVar2LabelMap()->empty()) + { + var2_label_map += ", var2_label_map:'"+ extractLabelMap2String(stmt->getVar2LabelMap()) +"'"; + } + std::string fieldsStr = ""; + fieldsStr += "edge_id: " + std::to_string(stmt->getEdgeID()) + + valueStr + + bb_id_str + + icfg_node_id_str + + inst2_label_map + + var2_label_map + + ", call_edge_label_counter:" + std::to_string(*(stmt->getCallEdgeLabelCounter())) + + ", store_edge_label_counter:" + std::to_string(*(stmt->getStoreEdgeLabelCounter())) + + ", multi_opnd_label_counter:" + std::to_string(*(stmt->getMultiOpndLabelCounter())) + + ", edge_flag:" + std::to_string(stmt->getEdgeKindWithoutMask()); + return fieldsStr; +} + +const std::string GraphDBClient::SVFStmt2DBString(const SVFStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); + std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + + " CREATE (n)-[r:SVFStmt{"+ + generateSVFStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::AssignStmt2DBString(const AssignStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + const std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:" + srcKind + "{id:" + std::to_string(stmt->getRHSVar()->getId()) + + "}), (m:" + dstKind + "{id:" + std::to_string(stmt->getLHSVar()->getId()) + + "}) WHERE n.id = " + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:AssignStmt{" + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::AddrStmt2DBString(const AddrStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:AddrStmt{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", arr_size:'" + extractNodesIds(stmt->getArrSize()) +"'"+ + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::CopyStmt2DBString(const CopyStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:CopyStmt{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", copy_kind:" + std::to_string(stmt->getCopyKind()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::StoreStmt2DBString(const StoreStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:StoreStmt{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::LoadStmt2DBString(const LoadStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:LoadStmt{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::GepStmt2DBString(const GepStmt* stmt) +{ + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + std::ostringstream accessPathStr; + accessPathStr << ""; + if (!stmt->isVariantFieldGep()) + { + accessPathStr << ", ap_fld_idx:" + << std::to_string(stmt->getConstantStructFldIdx()); + } + else + { + accessPathStr << ", ap_fld_idx:-1"; + } + + if (nullptr != stmt->getAccessPath().gepSrcPointeeType()) + { + accessPathStr << ", ap_gep_pointee_type_id:"<< stmt->getAccessPath().gepSrcPointeeType()->getId(); + } + else + { + accessPathStr << ", ap_gep_pointee_type_id:-1"; + } + if (!stmt->getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathStr << ", ap_idx_operand_pairs:'" + << IdxOperandPairsToString(&(stmt->getAccessPath().getIdxOperandPairVec())) + << "'"; + } + + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + accessPathStr.str() + + ", variant_field:" + (stmt->isVariantFieldGep()? "true" : "false") + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::CallPE2DBString(const CallPE* stmt) +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != stmt->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != stmt->getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(stmt->getFunEntryICFGNode()->getId()); + } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:CallPE{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::RetPE2DBString(const RetPE* stmt) +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != stmt->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != stmt->getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(stmt->getFunExitICFGNode()->getId()); + } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:RetPE{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::MultiOpndStmt2DBString(const MultiOpndStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:MultiOpndStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::PhiStmt2DBString(const PhiStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:PhiStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", op_icfg_nodes_ids:'" + extractNodesIds(*(stmt->getOpICFGNodeVec())) + "'"+ + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::SelectStmt2DBString(const SelectStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:SelectStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", condition_svf_var_node_id:" + std::to_string(stmt->getCondition()->getId()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::CmpStmt2DBString(const CmpStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:CmpStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", predicate:" + std::to_string(stmt->getPredicate()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::BinaryOPStmt2DBString(const BinaryOPStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:BinaryOPStmt{"+ + generateMultiOpndStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", op_code:" + std::to_string(stmt->getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::UnaryOPStmt2DBString(const UnaryOPStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:UnaryOPStmt{"+ + generateSVFStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", op_code:" + std::to_string(stmt->getOpcode()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::BranchStmt2DBString(const BranchStmt* stmt) +{ + const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); + const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + + " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + + " CREATE (n)-[r:BranchStmt{"+ + generateSVFStmtEdgeFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + ", successors:'" + extractSuccessorsPairSet2String(&(stmt->getSuccessors())) + "'"+ + ", condition_svf_var_node_id:" + std::to_string(stmt->getCondition()->getId()) + + ", br_inst_svf_var_node_id:" + std::to_string(stmt->getBranchInst()->getId()) + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::TDForkPE2DBString(const TDForkPE* stmt) +{ + std::string callInstStr = ""; + std::string funEntryICFGNodeStr = ""; + if (nullptr != stmt->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != stmt->getFunEntryICFGNode()) + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(stmt->getFunEntryICFGNode()->getId()); + } + else + { + funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; + } + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:TDForkPE{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + callInstStr + + funEntryICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::TDJoinPE2DBString(const TDJoinPE* stmt) +{ + std::string callInstStr = ""; + std::string funExitICFGNodeStr = ""; + if (nullptr != stmt->getCallInst()) + { + callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); + } + else + { + callInstStr += ", call_icfg_node_id:-1"; + } + + if (nullptr != stmt->getFunExitICFGNode()) + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(stmt->getFunExitICFGNode()->getId()); + } + else + { + funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; + } + std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); + std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); + const std::string queryStatement = + "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+ + dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + + std::to_string(stmt->getRHSVar()->getId()) + + " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + + " CREATE (n)-[r:TDJoinPE{"+ + generateAssignStmtFieldsStmt(stmt) + + ", kind:" + std::to_string(stmt->getEdgeKind()) + + callInstStr + + funExitICFGNodeStr + + "}]->(m)"; + return queryStatement; +} + +const std::string GraphDBClient::valVar2DBString(const ValVar* var) +{ + const std::string queryStatement ="CREATE (n:ValVar {"+ + getValVarNodeFieldsStmt(var)+ + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::objVar2DBString(const ObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ObjVar {"+ + getObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::argValVar2DBString(const ArgValVar* var) +{ + const std::string queryStatement ="CREATE (n:ArgValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", cg_node_id:" + std::to_string(var->getParent()->getId()) + + ", arg_no:" + std::to_string(var->getArgNo()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::gepValVar2DBString(const GepValVar* var) +{ + std::ostringstream accessPathFieldsStr; + accessPathFieldsStr << ""; + + if (nullptr != var->getAccessPath().gepSrcPointeeType()) + { + accessPathFieldsStr << ", ap_gep_pointee_type_id:"<getAccessPath().gepSrcPointeeType()->getId(); + } + else + { + accessPathFieldsStr << ", ap_gep_pointee_type_id:-1"; + } + if (!var->getAccessPath().getIdxOperandPairVec().empty()) + { + accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< IdxOperandPairsToString(&(var->getAccessPath().getIdxOperandPairVec()))<<"'"; + } + const std::string queryStatement ="CREATE (n:GepValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", base_val_id:" + std::to_string(var->getBaseNode()->getId()) + + ", gep_val_svf_type_id:"+std::to_string(var->getType()->getId()) + + ", ap_fld_idx:"+std::to_string(var->getConstantFieldIdx()) + + ", llvm_var_inst_id:" + std::to_string(var->getLLVMVarInstID()) + + accessPathFieldsStr.str() + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::baseObjVar2DBString(const BaseObjVar* var) +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::gepObjVar2DBString(const GepObjVar* var) +{ + const std::string queryStatement ="CREATE (n:BaseObjVar {"+ + getObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", base_obj_var_node_id:" + std::to_string(var->getBaseObj()->getId()) + + ", app_offset:" + std::to_string(var->getConstantFieldIdx()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::heapObjVar2DBString(const HeapObjVar* var) +{ + const std::string queryStatement ="CREATE (n:HeapObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::stackObjVar2DBString(const StackObjVar* var) +{ + const std::string queryStatement ="CREATE (n:StackObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::funObjVar2DBString(const FunObjVar* var) +{ + std::ostringstream exitBBStr; + if (var->hasBasicBlock() && nullptr != var->getExitBB()) + { + exitBBStr << ", exit_bb_id:" << std::to_string(var->getExitBB()->getId()); + } + else + { + exitBBStr << ", exit_bb_id:-1"; + } + std::string annotationsStr = ""; + std::vector annotationsVector; + annotationsVector = ExtAPI::getExtAPI()->getExtFuncAnnotations(var); + if (annotationsVector.size() > 0) + { + annotationsStr = serializeAnnotations(annotationsVector); + } + std::ostringstream valNameStr; + if (var->getName().empty()) + { + valNameStr << ",val_name:''"; + } + else + { + valNameStr << ",val_name:'"<getName()<<"'"; + } + const std::string queryStatement ="CREATE (n:FunObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", is_decl:" + (var->isDeclaration()? "true" : "false") + + ", intrinsic:" + (var->isIntrinsic()? "true" : "false") + + ", is_addr_taken:" + (var->hasAddressTaken()? "true" : "false") + + ", is_uncalled:" + (var->isUncalledFunction()? "true" : "false") + + ", is_not_ret:" + (var->getIsNotRet()? "true" : "false") + + ", sup_var_arg:" + (var->isVarArg()? "true" : "false") + + ", fun_type_id:" + std::to_string(var->getFunctionType()->getId()) + + ", real_def_fun_node_id:" + std::to_string(var->getDefFunForMultipleModule()->getId()) + // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) + + exitBBStr.str() + + ", all_args_node_ids:'" + extractNodesIds(var->getArgs()) + "'" + + ", reachable_bbs:'" + extractNodesIds(var->getReachableBBs()) + "'" + + ", dt_bbs_map:'" + extractBBsMapWithSet2String(&(var->getDomTreeMap())) + "'" + + ", pdt_bbs_map:'" + extractBBsMapWithSet2String(&(var->getLoopAndDomInfo()->getPostDomTreeMap())) + "'" + + ", df_bbs_map:'" + extractBBsMapWithSet2String(&(var->getDomFrontierMap())) + "'" + + ", bb2_loop_map:'" + extractBBsMapWithSet2String(&(var->getLoopAndDomInfo()->getBB2LoopMap())) + "'" + + ", bb2_p_dom_level:'" + extractLabelMap2String(&(var->getLoopAndDomInfo()->getBBPDomLevel())) + "'" + + ", bb2_pi_dom:'" + extractBBsMap2String(&(var->getLoopAndDomInfo()->getBB2PIdom())) + "'" + + ", func_annotation:'" + annotationsStr + "'" + + valNameStr.str() + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::funValVar2DBString(const FunValVar* var) +{ + const std::string queryStatement ="CREATE (n:FunValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", fun_obj_var_node_id:" + std::to_string(var->getFunction()->getId()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::globalValVar2DBString(const GlobalValVar* var) +{ + const std::string queryStatement ="CREATE (n:GlobalValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constAggValVar2DBString(const ConstAggValVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constDataValVar2DBString(const ConstDataValVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ + getConstDataValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::blackHoleValVar2DBString(const BlackHoleValVar* var) +{ + const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ + getConstDataValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constFPValVar2DBString(const ConstFPValVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ + getConstDataValVarNodeFieldsStmt(var) + +", kind:" + std::to_string(var->getNodeKind()) + +", dval:"+ std::to_string(var->getFPValue()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constIntValVar2DBString(const ConstIntValVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ + getConstDataValVarNodeFieldsStmt(var) + +", kind:" + std::to_string(var->getNodeKind()) + +", zval:'"+ std::to_string(var->getZExtValue()) + "'" + +", sval:"+ std::to_string(var->getSExtValue()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constNullPtrValVar2DBString(const ConstNullPtrValVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ + getConstDataValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::globalObjVar2DBString(const GlobalObjVar* var) +{ + const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constAggObjVar2DBString(const ConstAggObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constDataObjVar2DBString(const ConstDataObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ + getConstDataObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constFPObjVar2DBString(const ConstFPObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ + getConstDataObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", dval:" + std::to_string(var->getFPValue()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constIntObjVar2DBString(const ConstIntObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ + getConstDataObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + ", zval:'" + std::to_string(var->getZExtValue()) + "'" + + ", sval:" + std::to_string(var->getSExtValue()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::constNullPtrObjVar2DBString(const ConstNullPtrObjVar* var) +{ + const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ + getConstDataObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::retValPN2DBString(const RetValPN* var) +{ + const std::string queryStatement ="CREATE (n:RetValPN {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + +", call_graph_node_id:"+std::to_string(var->getCallGraphNode()->getId()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::varArgValPN2DBString(const VarArgValPN* var) +{ + const std::string queryStatement ="CREATE (n:VarArgValPN {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + +", call_graph_node_id:"+std::to_string(var->getFunction()->getId()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::dummyValVar2DBString(const DummyValVar* var) +{ + const std::string queryStatement ="CREATE (n:DummyValVar {"+ + getValVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + +const std::string GraphDBClient::dummyObjVar2DBString(const DummyObjVar* var) +{ + const std::string queryStatement ="CREATE (n:DummyObjVar {"+ + getBaseObjVarNodeFieldsStmt(var) + + ", kind:" + std::to_string(var->getNodeKind()) + + "})"; + return queryStatement; +} + diff --git a/svf/lib/SVFIR/SVFStatements.cpp b/svf/lib/SVFIR/SVFStatements.cpp index 5295ad701..4956003fa 100644 --- a/svf/lib/SVFIR/SVFStatements.cpp +++ b/svf/lib/SVFIR/SVFStatements.cpp @@ -411,465 +411,3 @@ BinaryOPStmt::BinaryOPStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar { assert(opnds.size() == 2 && "BinaryOPStmt can only have two operands!"); } - -std::string SVFStmt::generateSVFStmtEdgeFieldsStmt() const -{ - std::string valueStr = ""; - if (nullptr != getValue()) - { - valueStr += ", svf_var_node_id:"+ std::to_string(getValue()->getId()); - } - else - { - valueStr += ", svf_var_node_id:-1"; - } - std::string bb_id_str = ""; - if (nullptr != getBB()) - { - bb_id_str += ", bb_id:'" + std::to_string(getBB()->getParent()->getId()) + ":" + std::to_string(getBB()->getId())+"'"; - } - else - { - bb_id_str += ", bb_id:''"; - } - - std::string icfg_node_id_str = ""; - if (nullptr != getICFGNode()) - { - icfg_node_id_str += ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); - } - else - { - icfg_node_id_str += ", icfg_node_id:-1"; - } - - std::string inst2_label_map = ""; - if (nullptr != getInst2LabelMap() && !getInst2LabelMap()->empty()) - { - inst2_label_map += ", inst2_label_map:'"+ GraphDBClient::getInstance().extractLabelMap2String(getInst2LabelMap()) +"'"; - } - - std::string var2_label_map = ""; - if (nullptr != getVar2LabelMap() && !getVar2LabelMap()->empty()) - { - var2_label_map += ", var2_label_map:'"+ GraphDBClient::getInstance().extractLabelMap2String(getVar2LabelMap()) +"'"; - } - std::string fieldsStr = ""; - fieldsStr += "edge_id: " + std::to_string(getEdgeID()) + - valueStr + - bb_id_str + - icfg_node_id_str + - inst2_label_map + - var2_label_map + - ", call_edge_label_counter:" + std::to_string(*(getCallEdgeLabelCounter())) + - ", store_edge_label_counter:" + std::to_string(*(getStoreEdgeLabelCounter())) + - ", multi_opnd_label_counter:" + std::to_string(*(getMultiOpndLabelCounter())) + - ", edge_flag:" + std::to_string(getEdgeKindWithoutMask()); - return fieldsStr; -} - -std::string SVFStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getSrcNode()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(getSrcNode()->getId()) + - " AND m.id = " + std::to_string(getDstNode()->getId()) + - " CREATE (n)-[r:SVFStmt{"+ - generateSVFStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string AddrStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:AddrStmt{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", arr_size:'" + GraphDBClient::getInstance().extractNodesIds(getArrSize()) +"'"+ - "}]->(m)"; - return queryStatement; -} - -std::string CopyStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:CopyStmt{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", copy_kind:" + std::to_string(getCopyKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string StoreStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:StoreStmt{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string LoadStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:LoadStmt{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string GepStmt::toDBString() const -{ - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - std::ostringstream accessPathStr; - accessPathStr << ""; - if (!isVariantFieldGep()) - { - accessPathStr << ", ap_fld_idx:" - << std::to_string(getConstantStructFldIdx()); - } - else - { - accessPathStr << ", ap_fld_idx:-1"; - } - - if (nullptr != getAccessPath().gepSrcPointeeType()) - { - accessPathStr << ", ap_gep_pointee_type_id:"<< getAccessPath().gepSrcPointeeType()->getId(); - } - else - { - accessPathStr << ", ap_gep_pointee_type_id:-1"; - } - if (!getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathStr << ", ap_idx_operand_pairs:'" - << GraphDBClient::getInstance().IdxOperandPairsToString( - &(getAccessPath().getIdxOperandPairVec())) - << "'"; - } - - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - accessPathStr.str() + - ", variant_field:" + (isVariantFieldGep()? "true" : "false") + - "}]->(m)"; - return queryStatement; -} - -std::string CallPE::toDBString() const -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:CallPE{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string RetPE::toDBString() const -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:RetPE{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string TDForkPE::toDBString() const -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:TDForkPE{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string TDJoinPE::toDBString() const -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:TDJoinPE{"+ - generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -std::string MultiOpndStmt::generateMultiOpndStmtEdgeFieldsStmt() const -{ - std::string stmt = generateSVFStmtEdgeFieldsStmt(); - if (!getOpndVars().empty()) - { - stmt += ", op_var_node_ids:'" + GraphDBClient::getInstance().extractNodesIds(getOpndVars())+"'"; - } - else - { - stmt += ", op_var_node_ids:''"; - } - return stmt; -} - -std::string MultiOpndStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:MultiOpndStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -std::string PhiStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:PhiStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", op_icfg_nodes_ids:'" + GraphDBClient::getInstance().extractNodesIds(*(getOpICFGNodeVec())) + "'"+ - "}]->(m)"; - return queryStatement; -} - -std::string SelectStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:SelectStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", condition_svf_var_node_id:" + std::to_string(getCondition()->getId()) + - "}]->(m)"; - return queryStatement; -} - -std::string CmpStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:CmpStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", predicate:" + std::to_string(getPredicate()) + - "}]->(m)"; - return queryStatement; -} - -std::string BinaryOPStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:BinaryOPStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", op_code:" + std::to_string(getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -std::string UnaryOPStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:UnaryOPStmt{"+ - generateSVFStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", op_code:" + std::to_string(getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -std::string BranchStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getSrcNode()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:BranchStmt{"+ - generateSVFStmtEdgeFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + - ", successors:'" + GraphDBClient::getInstance().extractSuccessorsPairSet2String(&(getSuccessors())) + "'"+ - ", condition_svf_var_node_id:" + std::to_string(getCondition()->getId()) + - ", br_inst_svf_var_node_id:" + std::to_string(getBranchInst()->getId()) + - "}]->(m)"; - return queryStatement; -} - -std::string AssignStmt::toDBString() const -{ - const std::string srcKind = GraphDBClient::getInstance().getPAGNodeKindString(getRHSVar()); - const std::string dstKind = GraphDBClient::getInstance().getPAGNodeKindString(getLHSVar()); - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(getRHSVar()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(getLHSVar()->getId()) + - "}) WHERE n.id = " + std::to_string(getRHSVar()->getId()) + - " AND m.id = " + std::to_string(getLHSVar()->getId()) + - " CREATE (n)-[r:AssignStmt{" + generateAssignStmtFieldsStmt() + - ", kind:" + std::to_string(getEdgeKind()) + "}]->(m)"; - return queryStatement; -} \ No newline at end of file diff --git a/svf/lib/SVFIR/SVFType.cpp b/svf/lib/SVFIR/SVFType.cpp index 7729c7143..0efaf4eae 100644 --- a/svf/lib/SVFIR/SVFType.cpp +++ b/svf/lib/SVFIR/SVFType.cpp @@ -90,48 +90,4 @@ void SVFOtherType::print(std::ostream& os) const os << repr; } -std::string SVFFunctionType::toDBString() const -{ - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFFunctionType {id:" + std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + - ", params_types_vec:'" + GraphDBClient::getInstance().extractSVFTypes(getParamTypes()) + - "', ret_ty_node_id:" + std::to_string(getReturnType()->getId()) + "})"; - return queryStatement; -} - -std::string StInfo::toDBString() const -{ - const std::string queryStatement ="CREATE (n:StInfo {st_info_id:" + std::to_string(getStinfoId()) + - ", fld_idx_vec:'" + GraphDBClient::getInstance().extractIdxs(getFlattenedFieldIdxVec()) + - "', elem_idx_vec:'" + GraphDBClient::getInstance().extractIdxs(getFlattenedElemIdxVec()) + - "', finfo_types:'" + GraphDBClient::getInstance().extractSVFTypes(getFlattenFieldTypes()) + - "', flatten_element_types:'" + GraphDBClient::getInstance().extractSVFTypes(getFlattenElementTypes()) + - "', fld_idx_2_type_map:'" + GraphDBClient::getInstance().extractFldIdx2TypeMap(getFldIdx2TypeMap()) + - "', stride:" + std::to_string(getStride()) + - ", num_of_flatten_elements:" + std::to_string(getNumOfFlattenElements()) + - ", num_of_flatten_fields:" + std::to_string(getNumOfFlattenFields()) + "})"; - return queryStatement; -} - -std::string SVFStructType::toDBString() const -{ - std::string is_single_val_ty = isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFStructType {id:" + std::to_string(getId()) + - ", svf_i8_type_id:" + std::to_string(getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(getSVFPtrType()->getId()) + - ", kind:" + std::to_string(getKind()) + - ", stinfo_node_id:" + std::to_string(getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(getByteSize()) + - ", struct_name:'" + getName() + "'" + - ", fields_id_vec:'" + GraphDBClient::getInstance().extractSVFTypes(getFieldTypes()) + - "'})"; - return queryStatement; -} - } // namespace SVF \ No newline at end of file diff --git a/svf/lib/SVFIR/SVFVariables.cpp b/svf/lib/SVFIR/SVFVariables.cpp index fe6cefd4e..d8a49f7fe 100644 --- a/svf/lib/SVFIR/SVFVariables.cpp +++ b/svf/lib/SVFIR/SVFVariables.cpp @@ -33,7 +33,6 @@ #include "Util/Options.h" #include "Util/SVFUtil.h" #include "Graphs/CallGraph.h" -#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; @@ -530,390 +529,3 @@ const std::string DummyObjVar::toString() const return rawstr.str(); } -std::string SVFVar::getSVFVarNodeFieldsStmt() const -{ - std::string fieldsStr = ""; - fieldsStr += "id: " + std::to_string(getId()) + - ", svf_type_id:"+ std::to_string(getType()->getId()) + - ", in_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getInEdgeKindToSetMap()) + - "', out_edge_kind_to_set_map:'" + GraphDBClient::getInstance().pagEdgeToSetMapTyToString(getOutEdgeKindToSetMap()) + - "'" + sourceLocToDBString(); - return fieldsStr; -} - -std::string ValVar::getValVarNodeFieldsStmt() const -{ - std::string fieldsStr = getSVFVarNodeFieldsStmt(); - if ( nullptr != getICFGNode()) - { - fieldsStr += ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); - } - else - { - fieldsStr += ", icfg_node_id:-1"; - } - return fieldsStr; -} - -std::string ValVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ValVar {"+ - getValVarNodeFieldsStmt()+ - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstDataValVar::getConstDataValVarNodeFieldsStmt() const -{ - return ValVar::getValVarNodeFieldsStmt(); -} - -std::string ConstDataValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ - getConstDataValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string BlackHoleValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ - getConstDataValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstFPValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ - getConstDataValVarNodeFieldsStmt() - +", kind:" + std::to_string(getNodeKind()) - +", dval:"+ std::to_string(getFPValue()) - + "})"; - return queryStatement; -} - -std::string ConstIntValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ - getConstDataValVarNodeFieldsStmt() - +", kind:" + std::to_string(getNodeKind()) - +", zval:'"+ std::to_string(getZExtValue()) + "'" - +", sval:"+ std::to_string(getSExtValue()) - + "})"; - return queryStatement; -} - -std::string ConstNullPtrValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ - getConstDataValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string RetValPN::toDBString()const -{ - const std::string queryStatement ="CREATE (n:RetValPN {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - +", call_graph_node_id:"+std::to_string(getCallGraphNode()->getId()) - + "})"; - return queryStatement; -} - -std::string VarArgValPN::toDBString()const -{ - const std::string queryStatement ="CREATE (n:VarArgValPN {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - +", call_graph_node_id:"+std::to_string(getFunction()->getId()) - + "})"; - return queryStatement; -} - -std::string DummyValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:DummyValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstAggValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GlobalValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:GlobalValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string FunValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:FunValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", fun_obj_var_node_id:" + std::to_string(getFunction()->getId()) - + "})"; - return queryStatement; -} - -std::string GepValVar::toDBString()const -{ - std::ostringstream accessPathFieldsStr; - accessPathFieldsStr << ""; - - if (nullptr != getAccessPath().gepSrcPointeeType()) - { - accessPathFieldsStr << ", ap_gep_pointee_type_id:"<getId(); - } - else - { - accessPathFieldsStr << ", ap_gep_pointee_type_id:-1"; - } - if (!getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< GraphDBClient::getInstance().IdxOperandPairsToString(&(getAccessPath().getIdxOperandPairVec()))<<"'"; - } - const std::string queryStatement ="CREATE (n:GepValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", base_val_id:" + std::to_string(getBaseNode()->getId()) - + ", gep_val_svf_type_id:"+std::to_string(getType()->getId()) - + ", ap_fld_idx:"+std::to_string(getConstantFieldIdx()) - + ", llvm_var_inst_id:" + std::to_string(getLLVMVarInstID()) - + accessPathFieldsStr.str() - + "})"; - return queryStatement; -} - -std::string ArgValVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ArgValVar {"+ - getValVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", cg_node_id:" + std::to_string(getParent()->getId()) - + ", arg_no:" + std::to_string(getArgNo()) - + "})"; - return queryStatement; -} - -std::string ObjVar::getObjVarNodeFieldsStmt() const -{ - return SVFVar::getSVFVarNodeFieldsStmt(); -} - -std::string ObjVar::toDBString()const -{ - const std::string queryStatement ="CREATE (n:ObjVar {"+ - getObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string BaseObjVar::getBaseObjVarNodeFieldsStmt() const -{ - std::string fieldsStr; - std::string icfgIDstr = ""; - if ( nullptr != getICFGNode()) - { - icfgIDstr = ", icfg_node_id:" + std::to_string(getICFGNode()->getId()); - } - else - { - icfgIDstr = ", icfg_node_id:-1"; - } - std::string objTypeInfo_byteSize_str = ""; - if (isConstantByteSize()) - { - objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + std::to_string(getByteSizeOfObj()); - } - fieldsStr += getObjVarNodeFieldsStmt() + - icfgIDstr + - ", obj_type_info_type_id:" + std::to_string(getTypeInfo()->getType()->getId()) + - ", obj_type_info_flags:" + std::to_string(getTypeInfo()->getFlag()) + - ", obj_type_info_max_offset_limit:" + std::to_string(getMaxFieldOffsetLimit()) + - ", obj_type_info_elem_num:" + std::to_string(getNumOfElements()) + - objTypeInfo_byteSize_str; - return fieldsStr; -} - -std::string BaseObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GepObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", base_obj_var_node_id:" + std::to_string(getBaseObj()->getId()) - + ", app_offset:" + std::to_string(getConstantFieldIdx()) - + "})"; - return queryStatement; -} - -std::string HeapObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:HeapObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string StackObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:StackObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstDataObjVar::getConstDataObjVarNodeFieldsStmt() const -{ - return getBaseObjVarNodeFieldsStmt(); -} - -std::string ConstDataObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ - getConstDataObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstNullPtrObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ - getConstDataObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstIntObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ - getConstDataObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", zval:'" + std::to_string(getZExtValue()) + "'" - + ", sval:" + std::to_string(getSExtValue()) - + "})"; - return queryStatement; -} - -std::string ConstFPObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ - getConstDataObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + ", dval:" + std::to_string(getFPValue()) - + "})"; - return queryStatement; -} - -std::string DummyObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:DummyObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string ConstAggObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string GlobalObjVar::toDBString() const -{ - const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ - getBaseObjVarNodeFieldsStmt() - + ", kind:" + std::to_string(getNodeKind()) - + "})"; - return queryStatement; -} - -std::string FunObjVar::toDBString() const -{ - std::ostringstream exitBBStr; - if (hasBasicBlock() && nullptr != getExitBB()) - { - exitBBStr << ", exit_bb_id:" << std::to_string(getExitBB()->getId()); - } - else - { - exitBBStr << ", exit_bb_id:-1"; - } - std::string annotationsStr = ""; - std::vector annotationsVector; - annotationsVector = ExtAPI::getExtAPI()->getExtFuncAnnotations(this); - if (annotationsVector.size() > 0) - { - annotationsStr = GraphDBClient::getInstance().serializeAnnotations(annotationsVector); - } - std::ostringstream valNameStr; - if (getName().empty()) - { - valNameStr << ",val_name:''"; - } - else - { - valNameStr << ",val_name:'"<getId()) - + ", real_def_fun_node_id:" + std::to_string(getDefFunForMultipleModule()->getId()) - // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) - + exitBBStr.str() - + ", all_args_node_ids:'" + GraphDBClient::getInstance().extractNodesIds(getArgs()) + "'" - + ", reachable_bbs:'" + GraphDBClient::getInstance().extractNodesIds(getReachableBBs()) + "'" - + ", dt_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getDomTreeMap())) + "'" - + ", pdt_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getLoopAndDomInfo()->getPostDomTreeMap())) + "'" - + ", df_bbs_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getDomFrontierMap())) + "'" - + ", bb2_loop_map:'" + GraphDBClient::getInstance().extractBBsMapWithSet2String(&(getLoopAndDomInfo()->getBB2LoopMap())) + "'" - + ", bb2_p_dom_level:'" + GraphDBClient::getInstance().extractLabelMap2String(&(getLoopAndDomInfo()->getBBPDomLevel())) + "'" - + ", bb2_pi_dom:'" + GraphDBClient::getInstance().extractBBsMap2String(&(getLoopAndDomInfo()->getBB2PIdom())) + "'" - + ", func_annotation:'" + annotationsStr + "'" - + valNameStr.str() - + "})"; - return queryStatement; -} \ No newline at end of file From e9e488f4d7dbe5a1491f444b4a4c8b2feb4c9484 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sat, 27 Sep 2025 03:32:34 +1000 Subject: [PATCH 08/19] refactor basicblock, callgraph update --- svf-llvm/tools/WPA/wpa.cpp | 6 +-- svf/include/Graphs/BasicBlockG.h | 9 +---- svf/include/Graphs/CallGraph.h | 24 +++--------- svf/lib/Graphs/BasicBlockG.cpp | 11 +++++- svf/lib/Graphs/CallGraph.cpp | 65 +++++++++++++++++++++----------- svf/lib/SVFIR/GraphDBClient.cpp | 14 +++---- 6 files changed, 70 insertions(+), 59 deletions(-) diff --git a/svf-llvm/tools/WPA/wpa.cpp b/svf-llvm/tools/WPA/wpa.cpp index 3980a2476..a64023efb 100644 --- a/svf-llvm/tools/WPA/wpa.cpp +++ b/svf-llvm/tools/WPA/wpa.cpp @@ -46,11 +46,7 @@ int main(int argc, char** argv) // Refers to content of a singleton unique_ptr in SVFIR. SVFIR* pag; - if (Options::ReadJson()) - { - assert(false && "please implement SVFIRReader::read"); - } - else if (Options::ReadFromDB()) + if (Options::ReadFromDB()) { SVFIRBuilder builder; pag = builder.build(); diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index cab183db8..78f9c7d82 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -63,7 +63,6 @@ class BasicBlockEdge: public GenericBasicBlockEdgeTy //@} virtual const std::string toString() const; - }; @@ -315,16 +314,12 @@ class BasicBlockGraph: public GenericBasicBlockGraphTy { id++; SVFBasicBlock* bb = new SVFBasicBlock(id, nullptr); - addGNode(id, bb); bb->setName(bbname); + addBasicBlock(bb); return bb; } - void addBasicBlockFromDB(SVFBasicBlock* bb) - { - id++; - addGNode(bb->getId(), bb); - } + void addBasicBlock(SVFBasicBlock* bb); }; } diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index 1ac0f8a65..857260c60 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -297,25 +297,13 @@ class CallGraph : public GenericPTACallGraphTy if(it == csToIdMap.end()) { CallSiteID id = totalCallSiteNum++; - csToIdMap.insert(std::make_pair(newCS, id)); - idToCSMap.insert(std::make_pair(id, newCS)); + addCallSite(cs,callee,id); return id; } return it->second; } - inline void addCallSiteFromDB(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid) - { - std::pair newCS(std::make_pair(cs, callee)); - CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS); - if(it == csToIdMap.end()) - { - CallSiteID id = csid; - totalCallSiteNum++; - csToIdMap.insert(std::make_pair(newCS, id)); - idToCSMap.insert(std::make_pair(id, newCS)); - } - } + CallSiteID addCallSite(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid); /// Add call graph edge inline void addEdge(CallGraphEdge* edge) @@ -325,7 +313,7 @@ class CallGraph : public GenericPTACallGraphTy } /// add direct call graph edge from database [only used this function when loading cgEdges from db results] - void addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); + void addDirectCallGraphEdge(CallGraphEdge* cgEdge); public: /// Constructor CallGraph(CGEK k = NormCallGraph); @@ -385,7 +373,7 @@ class CallGraph : public GenericPTACallGraphTy void addCallGraphNode(const FunObjVar* fun); - void addCallGraphNodeFromDB(CallGraphNode* cgNode); + void addCallGraphNode(CallGraphNode* cgNode); /// Get call graph node //@{ @@ -440,7 +428,7 @@ class CallGraph : public GenericPTACallGraphTy CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId) const; - CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge); + CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge) const; /// Get call graph edge via nodes CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId); @@ -485,7 +473,7 @@ class CallGraph : public GenericPTACallGraphTy /// Add indirect call edges //@{ void addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* callerFun, const FunObjVar* calleeFun); - void addIndirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge); + void addIndirectCallGraphEdge(CallGraphEdge* cgEdge); //@} /// Get callsites invoking the callee diff --git a/svf/lib/Graphs/BasicBlockG.cpp b/svf/lib/Graphs/BasicBlockG.cpp index 30ddc7f9a..707830b50 100644 --- a/svf/lib/Graphs/BasicBlockG.cpp +++ b/svf/lib/Graphs/BasicBlockG.cpp @@ -1,6 +1,6 @@ #include "Graphs/BasicBlockG.h" #include "Graphs/ICFGNode.h" -#include "SVFIR/GraphDBClient.h" +#include "Util/Options.h" using namespace SVF; const std::string BasicBlockEdge::toString() const @@ -22,4 +22,13 @@ const std::string SVFBasicBlock::toString() const } rawstr << "\n----------------------------------------\n"; return rawstr.str(); +} + +void BasicBlockGraph::addBasicBlock(SVFBasicBlock* bb) +{ + if (Options::ReadFromDB()) + { + id++; + } + addGNode(bb->getId(), bb); } \ No newline at end of file diff --git a/svf/lib/Graphs/CallGraph.cpp b/svf/lib/Graphs/CallGraph.cpp index 75c936a1a..11b31cba2 100644 --- a/svf/lib/Graphs/CallGraph.cpp +++ b/svf/lib/Graphs/CallGraph.cpp @@ -34,6 +34,7 @@ #include "Util/SVFUtil.h" #include "SVFIR/GraphDBClient.h" #include +#include "Util/Options.h" using namespace SVF; using namespace SVFUtil; @@ -160,6 +161,24 @@ CallGraph::CallGraph(const CallGraph& other) } +CallSiteID CallGraph::addCallSite(const CallICFGNode* cs, const FunObjVar* callee, const CallSiteID csid) +{ + std::pair newCS(std::make_pair(cs, callee)); + if (Options::ReadFromDB()) + { + CallSiteToIdMap::const_iterator it = csToIdMap.find(newCS); + if(it != csToIdMap.end()) + { + return it->second; + } + totalCallSiteNum++; + } + csToIdMap.insert(std::make_pair(newCS, csid)); + idToCSMap.insert(std::make_pair(csid, newCS)); + return csid; + +} + /*! * Memory has been cleaned up at GenericGraph */ @@ -175,18 +194,10 @@ CallGraphEdge* CallGraph::hasGraphEdge(CallGraphNode* src, CallGraphEdge::CEDGEK kind, CallSiteID csId) const { CallGraphEdge edge(src,dst,kind,csId); - CallGraphEdge* outEdge = src->hasOutgoingEdge(&edge); - CallGraphEdge* inEdge = dst->hasIncomingEdge(&edge); - if (outEdge && inEdge) - { - assert(outEdge == inEdge && "edges not match"); - return outEdge; - } - else - return nullptr; + return hasGraphEdge(&edge); } -CallGraphEdge* CallGraph::hasGraphEdge(CallGraphEdge* cgEdge) +CallGraphEdge* CallGraph::hasGraphEdge(CallGraphEdge* cgEdge) const { CallGraphEdge* outEdge = cgEdge->getSrcNode()->hasOutgoingEdge(cgEdge); CallGraphEdge* inEdge = cgEdge->getDstNode()->hasIncomingEdge(cgEdge); @@ -234,14 +245,21 @@ void CallGraph::addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* { CallGraphEdge* edge = new CallGraphEdge(caller,callee, CallGraphEdge::CallRetEdge, csId); edge->addInDirectCallSite(cs); - addEdge(edge); + addIndirectCallGraphEdge(edge); callinstToCallGraphEdgesMap[cs].insert(edge); } } -void CallGraph::addIndirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge) +void CallGraph::addIndirectCallGraphEdge(CallGraphEdge* cgEdge) { - if (!hasGraphEdge(cgEdge)) + if (Options::ReadFromDB()) + { + if (!hasGraphEdge(cgEdge)) + { + addEdge(cgEdge); + } + } + else { addEdge(cgEdge); } @@ -381,12 +399,10 @@ void CallGraph::addCallGraphNode(const FunObjVar* fun) { NodeID id = callGraphNodeNum; CallGraphNode*callGraphNode = new CallGraphNode(id, fun); - addGNode(id, callGraphNode); - funToCallGraphNodeMap[callGraphNode->getFunction()] = callGraphNode; - callGraphNodeNum++; + addCallGraphNode(callGraphNode); } -void CallGraph::addCallGraphNodeFromDB(CallGraphNode* cgNode) +void CallGraph::addCallGraphNode(CallGraphNode* cgNode) { addGNode(cgNode->getId(), cgNode); funToCallGraphNodeMap[cgNode->getFunction()] = cgNode; @@ -417,14 +433,21 @@ void CallGraph::addDirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* c { CallGraphEdge* edge = new CallGraphEdge(caller,callee, CallGraphEdge::CallRetEdge, csId); edge->addDirectCallSite(cs); - addEdge(edge); + addDirectCallGraphEdge(edge); callinstToCallGraphEdgesMap[cs].insert(edge); } } -void CallGraph::addDirectCallGraphEdgeFromDB(CallGraphEdge* cgEdge) +void CallGraph::addDirectCallGraphEdge(CallGraphEdge* cgEdge) { - if (!hasGraphEdge(cgEdge)) + if (Options::ReadFromDB()) + { + if (!hasGraphEdge(cgEdge)) + { + addEdge(cgEdge); + } + } + else { addEdge(cgEdge); } @@ -512,4 +535,4 @@ struct DOTGraphTraits : public DefaultDOTGraphTraits return rawstr.str(); } }; -} // End namespace llvm \ No newline at end of file +} // End namespace llvm diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 69da6e400..9d9a62e37 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -2886,7 +2886,7 @@ void GraphDBClient::readBasicBlockNodesFromDB(lgraph::RpcClient* connection, con int bbId = parseBBId(id); SVFBasicBlock* bb = new SVFBasicBlock(bbId, funObjVar); bb->setName(bb_name); - bbGraph->addBasicBlockFromDB(bb); + bbGraph->addBasicBlock(bb); basicBlocks.insert(bb); std::string allICFGNodeIds = cJSON_GetObjectItem(properties, "all_icfg_nodes_ids")->valuestring; if (!allICFGNodeIds.empty()) @@ -3031,7 +3031,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseIntraICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addIntraICFGNodeFromDB(SVFUtil::cast(icfgNode)); + icfg->addIntraICFGNode(SVFUtil::cast(icfgNode)); } } else if (nodeType == "FunEntryICFGNode") @@ -3755,7 +3755,7 @@ void GraphDBClient::readCallGraphNodesFromDB(lgraph::RpcClient* connection, cons cgNode = parseCallGraphNodeFromDB(node); if (nullptr != cgNode) { - callGraph->addCallGraphNodeFromDB(cgNode); + callGraph->addCallGraphNode(cgNode); } skip += 1; } @@ -3787,11 +3787,11 @@ void GraphDBClient::readCallGraphEdgesFromDB(lgraph::RpcClient* connection, cons { if (cgEdge->isDirectCallEdge()) { - callGraph->addDirectCallGraphEdgeFromDB(cgEdge); + callGraph->addDirectCallGraphEdge(cgEdge); } if (cgEdge->isIndirectCallEdge()) { - callGraph->addIndirectCallGraphEdgeFromDB(cgEdge); + callGraph->addIndirectCallGraphEdge(cgEdge); } } skip += 1; @@ -3880,7 +3880,7 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* for (int directCallId : direct_call_set_ids) { CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(directCallId)); - callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); + callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addDirectCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); } @@ -3894,7 +3894,7 @@ CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* { CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(indirectCallId)); callGraph->numOfResolvedIndCallEdge++; - callGraph->addCallSiteFromDB(node, node->getFun(), cgEdge->getCallSiteID()); + callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); cgEdge->addInDirectCallSite(node); callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); } From 25103641f0a77b39139a0bfe79a112633834ab53 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sat, 27 Sep 2025 04:35:13 +1000 Subject: [PATCH 09/19] refactor icfg update --- svf-llvm/include/SVF-LLVM/ICFGBuilder.h | 2 +- svf/include/Graphs/ICFG.h | 45 +++++-------------------- svf/include/Graphs/ICFGEdge.h | 2 +- svf/lib/Graphs/ICFG.cpp | 23 ++++++++++--- svf/lib/SVFIR/GraphDBClient.cpp | 12 +++---- 5 files changed, 35 insertions(+), 49 deletions(-) diff --git a/svf-llvm/include/SVF-LLVM/ICFGBuilder.h b/svf-llvm/include/SVF-LLVM/ICFGBuilder.h index 6ce771c2a..204e2e968 100644 --- a/svf-llvm/include/SVF-LLVM/ICFGBuilder.h +++ b/svf-llvm/include/SVF-LLVM/ICFGBuilder.h @@ -148,7 +148,7 @@ class ICFGBuilder inline void addGlobalICFGNode() { icfg->globalBlockNode = new GlobalICFGNode(icfg->totalICFGNode++); - icfg->addICFGNode(icfg->globalBlockNode); + icfg->addGlobalICFGNode(icfg->globalBlockNode); } private: diff --git a/svf/include/Graphs/ICFG.h b/svf/include/Graphs/ICFG.h index bce0b06da..f0d31130b 100644 --- a/svf/include/Graphs/ICFG.h +++ b/svf/include/Graphs/ICFG.h @@ -175,12 +175,6 @@ class ICFG : public GenericICFGTy return intraIcfgNode; } - virtual inline void addIntraICFGNodeFromDB(IntraICFGNode* intraICFGNode) - { - totalICFGNode++; - addICFGNode(intraICFGNode); - } - virtual inline CallICFGNode* addCallICFGNode( const SVFBasicBlock* bb, const SVFType* ty, const FunObjVar* calledFunc, bool isVararg, bool isvcall, @@ -194,12 +188,6 @@ class ICFG : public GenericICFGTy return callICFGNode; } - virtual inline void addCallICFGNodeFromDB(CallICFGNode* callICFGNode) - { - totalICFGNode++; - addICFGNode(callICFGNode); - } - virtual inline RetICFGNode* addRetICFGNode(CallICFGNode* call) { RetICFGNode* retICFGNode = new RetICFGNode(totalICFGNode++, call); @@ -207,52 +195,35 @@ class ICFG : public GenericICFGTy addICFGNode(retICFGNode); return retICFGNode; } - virtual inline void addRetICFGNodeFromDB(RetICFGNode* retICFGNode) - { - totalICFGNode++; - addICFGNode(retICFGNode); - } virtual inline FunEntryICFGNode* addFunEntryICFGNode(const FunObjVar* svfFunc) { FunEntryICFGNode* sNode = new FunEntryICFGNode(totalICFGNode++,svfFunc); - addICFGNode(sNode); - return FunToFunEntryNodeMap[svfFunc] = sNode; + return addFunEntryICFGNode(sNode); } - virtual inline void addFunEntryICFGNodeFromDB(FunEntryICFGNode* funEntryICFGNode) + virtual inline FunEntryICFGNode* addFunEntryICFGNode(FunEntryICFGNode* funEntryICFGNode) { - totalICFGNode++; addICFGNode(funEntryICFGNode); - FunToFunEntryNodeMap[funEntryICFGNode->getFun()] = funEntryICFGNode; + return FunToFunEntryNodeMap[funEntryICFGNode->getFun()] = funEntryICFGNode; } - virtual inline void addGlobalICFGNodeFromDB(GlobalICFGNode* globalICFGNode) - { - totalICFGNode++; - this->globalBlockNode = globalICFGNode; - addICFGNode(globalICFGNode); - } + virtual void addGlobalICFGNode(GlobalICFGNode* globalICFGNode); virtual inline FunExitICFGNode* addFunExitICFGNode(const FunObjVar* svfFunc) { FunExitICFGNode* sNode = new FunExitICFGNode(totalICFGNode++, svfFunc); - addICFGNode(sNode); - return FunToFunExitNodeMap[svfFunc] = sNode; + return addFunExitICFGNode(sNode); } - virtual inline void addFunExitICFGNodeFromDB(FunExitICFGNode* funExitICFGNode) + virtual inline FunExitICFGNode* addFunExitICFGNode(FunExitICFGNode* funExitICFGNode) { - totalICFGNode++; addICFGNode(funExitICFGNode); - FunToFunExitNodeMap[funExitICFGNode->getFun()] = funExitICFGNode; + return FunToFunExitNodeMap[funExitICFGNode->getFun()] = funExitICFGNode; } /// Add a ICFG node - virtual inline void addICFGNode(ICFGNode* node) - { - addGNode(node->getId(),node); - } + virtual void addICFGNode(ICFGNode* node); public: /// Get a basic block ICFGNode diff --git a/svf/include/Graphs/ICFGEdge.h b/svf/include/Graphs/ICFGEdge.h index 539eac8f8..233ec4110 100644 --- a/svf/include/Graphs/ICFGEdge.h +++ b/svf/include/Graphs/ICFGEdge.h @@ -267,8 +267,8 @@ class RetCFGEdge : public ICFGEdge } //@} virtual const std::string toString() const; - }; + } // End namespace SVF #endif /* ICFGEdge_H_ */ diff --git a/svf/lib/Graphs/ICFG.cpp b/svf/lib/Graphs/ICFG.cpp index f6cfec7b8..ebdf1f2cd 100644 --- a/svf/lib/Graphs/ICFG.cpp +++ b/svf/lib/Graphs/ICFG.cpp @@ -150,7 +150,6 @@ const std::string CallICFGNode::toString() const return rawstr.str(); } - const std::string RetICFGNode::toString() const { std::string str; @@ -184,7 +183,6 @@ const std::string IntraCFGEdge::toString() const return rawstr.str(); } - const std::string CallCFGEdge::toString() const { std::string str; @@ -203,7 +201,6 @@ const std::string RetCFGEdge::toString() const return rawstr.str(); } - /// Return call ICFGNode at the callsite const CallICFGNode* RetCFGEdge::getCallSite() const { @@ -241,6 +238,24 @@ ICFG::~ICFG() icfgNodeToSVFLoopVec.clear(); } +void ICFG::addICFGNode(ICFGNode* node) +{ + if (Options::ReadFromDB()) + { + totalICFGNode++; + } + addGNode(node->getId(),node); +} + +void ICFG::addGlobalICFGNode(GlobalICFGNode* globalICFGNode) +{ + if (Options::ReadFromDB()) + { + this->globalBlockNode = globalICFGNode; + } + addICFGNode(globalICFGNode); +} + /// Add a function entry node FunEntryICFGNode* ICFG::getFunEntryICFGNode(const FunObjVar* fun) @@ -595,4 +610,4 @@ struct DOTGraphTraits : public DOTGraphTraits return rawstr.str(); } }; -} // End namespace llvm \ No newline at end of file +} // End namespace llvm diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp index 9d9a62e37..a882163d3 100644 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ b/svf/lib/SVFIR/GraphDBClient.cpp @@ -3023,7 +3023,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseGlobalICFGNodeFromDBResult(node); if (nullptr != icfgNode) { - icfg->addGlobalICFGNodeFromDB(SVFUtil::cast(icfgNode)); + icfg->addGlobalICFGNode(SVFUtil::cast(icfgNode)); } } else if (nodeType == "IntraICFGNode") @@ -3031,7 +3031,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseIntraICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addIntraICFGNode(SVFUtil::cast(icfgNode)); + icfg->addICFGNode(icfgNode); } } else if (nodeType == "FunEntryICFGNode") @@ -3039,7 +3039,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseFunEntryICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addFunEntryICFGNodeFromDB(SVFUtil::cast(icfgNode)); + icfg->addFunEntryICFGNode(SVFUtil::cast(icfgNode)); } } else if (nodeType == "FunExitICFGNode") @@ -3047,7 +3047,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseFunExitICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addFunExitICFGNodeFromDB(SVFUtil::cast(icfgNode)); + icfg->addFunExitICFGNode(SVFUtil::cast(icfgNode)); } } else if (nodeType == "RetICFGNode") @@ -3055,7 +3055,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std icfgNode = parseRetICFGNodeFromDBResult(node, pag); if (nullptr != icfgNode) { - icfg->addRetICFGNodeFromDB(SVFUtil::cast(icfgNode)); + icfg->addICFGNode(icfgNode); id2RetICFGNodeMap[icfgNode->getId()] = SVFUtil::cast(icfgNode); } } @@ -3065,7 +3065,7 @@ void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std if (nullptr != icfgNode) { CallICFGNode* callNode = SVFUtil::cast(icfgNode); - icfg->addCallICFGNodeFromDB(callNode); + icfg->addICFGNode(callNode); if (callNode->isIndirectCall()) { pag->addIndirectCallsites(callNode, callNode->getIndFunPtr()->getId()); From d213288b139cd7b1c7c4e677269656ea585e289a Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sat, 27 Sep 2025 04:50:18 +1000 Subject: [PATCH 10/19] refactor svfType update --- svf/include/Graphs/ICFGNode.h | 8 +------- svf/include/SVFIR/SVFType.h | 5 +---- svf/include/Util/SVFLoopAndDomInfo.h | 2 -- svf/lib/Graphs/BasicBlockG.cpp | 2 +- svf/lib/SVFIR/SVFType.cpp | 3 +-- 5 files changed, 4 insertions(+), 16 deletions(-) diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index b810eed45..b83b128e5 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -140,6 +140,7 @@ class ICFGNode : public GenericICFGNodeTy return isICFGNodeKinds(node->getNodeKind()); } + std::string sourceLocToDBString() const { std::string sourceLoc = ""; @@ -197,7 +198,6 @@ class GlobalICFGNode : public ICFGNode { return "Global ICFGNode"; } - }; /*! @@ -249,7 +249,6 @@ class IntraICFGNode : public ICFGNode { return isRet; } - }; class InterICFGNode : public ICFGNode @@ -283,7 +282,6 @@ class InterICFGNode : public ICFGNode return isInterICFGNodeKind(node->getNodeKind()); } - //@} }; @@ -362,7 +360,6 @@ class FunEntryICFGNode : public InterICFGNode const std::string toString() const override; const std::string getSourceLoc() const override; - }; /*! @@ -435,7 +432,6 @@ class FunExitICFGNode : public InterICFGNode const std::string toString() const override; const std::string getSourceLoc() const override; - }; /*! @@ -625,7 +621,6 @@ class CallICFGNode : public InterICFGNode return "CallICFGNode: " + ICFGNode::getSourceLoc(); } - inline void setIndFunPtr(const SVFVar* indFun) { assert(isIndirectCall() && "not a indirect call?"); @@ -723,7 +718,6 @@ class RetICFGNode : public InterICFGNode { return "RetICFGNode: " + ICFGNode::getSourceLoc(); } - }; } // End namespace SVF diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index 272aa9136..dfbab669e 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -172,7 +172,6 @@ class StInfo { return stride; } - }; class SVFType @@ -326,7 +325,6 @@ class SVFPointerType : public SVFType } void print(std::ostream& os) const override; - }; class SVFIntegerType : public SVFType @@ -414,7 +412,6 @@ class SVFFunctionType : public SVFType } void print(std::ostream& os) const override; - }; class SVFStructType : public SVFType @@ -683,4 +680,4 @@ template struct std::hash> } }; -#endif /* INCLUDE_SVFIR_SVFTYPE_H_ */ \ No newline at end of file +#endif /* INCLUDE_SVFIR_SVFTYPE_H_ */ diff --git a/svf/include/Util/SVFLoopAndDomInfo.h b/svf/include/Util/SVFLoopAndDomInfo.h index 8b3d99131..57ca4bb1b 100644 --- a/svf/include/Util/SVFLoopAndDomInfo.h +++ b/svf/include/Util/SVFLoopAndDomInfo.h @@ -42,8 +42,6 @@ class SVFLoopAndDomInfo { friend class GraphDBClient; - - public: typedef Set BBSet; typedef std::vector BBList; diff --git a/svf/lib/Graphs/BasicBlockG.cpp b/svf/lib/Graphs/BasicBlockG.cpp index 707830b50..8cdc0af28 100644 --- a/svf/lib/Graphs/BasicBlockG.cpp +++ b/svf/lib/Graphs/BasicBlockG.cpp @@ -31,4 +31,4 @@ void BasicBlockGraph::addBasicBlock(SVFBasicBlock* bb) id++; } addGNode(bb->getId(), bb); -} \ No newline at end of file +} diff --git a/svf/lib/SVFIR/SVFType.cpp b/svf/lib/SVFIR/SVFType.cpp index 0efaf4eae..a464cda7e 100644 --- a/svf/lib/SVFIR/SVFType.cpp +++ b/svf/lib/SVFIR/SVFType.cpp @@ -1,6 +1,5 @@ #include "SVFIR/SVFType.h" #include -#include "SVFIR/GraphDBClient.h" namespace SVF { @@ -90,4 +89,4 @@ void SVFOtherType::print(std::ostream& os) const os << repr; } -} // namespace SVF \ No newline at end of file +} // namespace SVF From e22365aeba092d9911232f200da98b84f6656830 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sat, 27 Sep 2025 07:20:16 +1000 Subject: [PATCH 11/19] refactor pag database update update update test ci update ci update ci update ci update ci updtae ci update update graphDBClient and cmake configuration update clean db client clean code update --- CMakeLists.txt | 2 - svf-llvm/CMakeLists.txt | 2 +- svf-llvm/lib/SVFIRBuilder.cpp | 30 +- svf-llvm/tools/WPA/CMakeLists.txt | 2 +- .../Graphs/DBSchema/BasicBlockEdgeSchema.json | 10 - .../Graphs/DBSchema/BasicBlockNodeSchema.json | 47 - .../Graphs/DBSchema/CHGEdgeSchema.json | 17 - .../Graphs/DBSchema/CHGNodeSchema.json | 41 - .../Graphs/DBSchema/CallGraphEdgeSchema.json | 35 - .../Graphs/DBSchema/CallGraphNodeSchema.json | 35 - .../Graphs/DBSchema/ICFGEdgeSchema.json | 65 - .../Graphs/DBSchema/ICFGNodeSchema.json | 378 -- .../Graphs/DBSchema/PAGEdgeSchema.json | 1463 ----- .../Graphs/DBSchema/PAGNodeSchema.json | 1916 ------- .../Graphs/DBSchema/SVFTypeNodeSchema.json | 383 -- svf/include/Graphs/IRGraph.h | 13 +- svf/include/SVFIR/GraphDBClient.h | 998 ---- svf/include/SVFIR/SVFIR.h | 148 +- svf/include/SVFIR/SVFVariables.h | 24 +- svf/lib/Graphs/CallGraph.cpp | 1 - svf/lib/Graphs/ICFG.cpp | 1 - svf/lib/Graphs/IRGraph.cpp | 7 +- svf/lib/SVFIR/GraphDBClient.cpp | 5042 ----------------- svf/lib/SVFIR/SVFIR.cpp | 212 +- svf/lib/SVFIR/SVFStatements.cpp | 1 - 25 files changed, 141 insertions(+), 10732 deletions(-) delete mode 100644 svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/CHGEdgeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/CHGNodeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/CallGraphNodeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/ICFGEdgeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/ICFGNodeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/PAGEdgeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/PAGNodeSchema.json delete mode 100644 svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json delete mode 100644 svf/include/SVFIR/GraphDBClient.h delete mode 100644 svf/lib/SVFIR/GraphDBClient.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 4a099eeb2..f5b9dd501 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -282,8 +282,6 @@ endif() # SVF core definitions # ================================================================================= -# Add the tugraph rpc library to all targets of SVF -find_library(LGRAPH_CPP_CLIENT_LIBRARIES lgraph_client_cpp_rpc REQUIRED PATHS /usr/local/lib) add_subdirectory(svf) add_subdirectory(svf-llvm) diff --git a/svf-llvm/CMakeLists.txt b/svf-llvm/CMakeLists.txt index 657471be7..66be7e4e9 100644 --- a/svf-llvm/CMakeLists.txt +++ b/svf-llvm/CMakeLists.txt @@ -125,7 +125,7 @@ endif() add_dependencies(SvfLLVM gen_extapi_ir) # Link the SVF LLVM library to the core library, the build/link flags, and the LLVM libraries -target_link_libraries(SvfLLVM PUBLIC SvfFlags ${LGRAPH_CPP_CLIENT_LIBRARIES} SvfCore ${LLVM_LIBRARIES}) +target_link_libraries(SvfLLVM PUBLIC SvfFlags SvfCore ${LLVM_LIBRARIES}) # Gather & set all of the core library's source files by globbing all .h and .cpp files (recursively) file(GLOB_RECURSE SVF_LLVM_HEADERS ${CMAKE_CURRENT_LIST_DIR}/include/*.h) diff --git a/svf-llvm/lib/SVFIRBuilder.cpp b/svf-llvm/lib/SVFIRBuilder.cpp index 06b6a3671..24c95560e 100644 --- a/svf-llvm/lib/SVFIRBuilder.cpp +++ b/svf-llvm/lib/SVFIRBuilder.cpp @@ -41,14 +41,12 @@ #include "Graphs/CallGraph.h" #include "Util/Options.h" #include "Util/SVFUtil.h" -#include "SVFIR/GraphDBClient.h" using namespace std; using namespace SVF; using namespace SVFUtil; using namespace LLVMUtil; -lgraph::RpcClient* dbConnection = SVF::GraphDBClient::getInstance().getConnection(); /*! * Start building SVFIR here @@ -66,23 +64,6 @@ SVFIR* SVFIRBuilder::build() return fileBuilder.build(); } - if (Options::ReadFromDB()) - { - GraphDBClient::getInstance().readSVFTypesFromDB(dbConnection, "SVFType", pag); - GraphDBClient::getInstance().initialSVFPAGNodesFromDB(dbConnection, "PAG",pag); - GraphDBClient::getInstance().readBasicBlockGraphFromDB(dbConnection, "BasicBlockGraph"); - ICFG* icfg = GraphDBClient::getInstance().buildICFGFromDB(dbConnection, "ICFG", pag); - pag->icfg = icfg; - CallGraph* callGraph = GraphDBClient::getInstance().buildCallGraphFromDB(dbConnection,"CallGraph",pag); - CHGraph* chg = new CHGraph(); - pag->setCHG(chg); - pag->callGraph = callGraph; - GraphDBClient::getInstance().updatePAGNodesFromDB(dbConnection, "PAG", pag); - GraphDBClient::getInstance().loadSVFPAGEdgesFromDB(dbConnection, "PAG",pag); - GraphDBClient::getInstance().parseSVFStmtsForICFGNodeFromDBResult(pag); - return pag; - } - // If the SVFIR has been built before, then we return the unique SVFIR of the program if(pag->getNodeNumAfterPAGBuild() > 1) return pag; @@ -178,15 +159,6 @@ SVFIR* SVFIRBuilder::build() pag->setNodeNumAfterPAGBuild(pag->getTotalNodeNum()); - if (Options::Write2DB()) { - std::string dbname = "SVFType"; - GraphDBClient::getInstance().insertSVFTypeNodeSet2db(&pag->getSVFTypes(), &pag->getStInfos(), dbname); - GraphDBClient::getInstance().insertPAG2db(pag); - GraphDBClient::getInstance().insertICFG2db(pag->icfg); - GraphDBClient::getInstance().insertCHG2db(chg); - GraphDBClient::getInstance().insertCallGraph2db(pag->callGraph); - } - // dump SVFIR if (Options::PAGDotGraph()) pag->dump("svfir_initial"); @@ -1848,4 +1820,4 @@ AccessPath SVFIRBuilder::getAccessPathFromBaseNode(NodeID nodeId) return AccessPath(0); else return gepEdge->getAccessPath(); -} \ No newline at end of file +} diff --git a/svf-llvm/tools/WPA/CMakeLists.txt b/svf-llvm/tools/WPA/CMakeLists.txt index af777ab1b..2b30226a9 100644 --- a/svf-llvm/tools/WPA/CMakeLists.txt +++ b/svf-llvm/tools/WPA/CMakeLists.txt @@ -3,4 +3,4 @@ set(THREADS_PREFER_PTHREAD_FLAG ON) add_llvm_executable(wpa wpa.cpp) find_package(Threads REQUIRED) -target_link_libraries(wpa PUBLIC ${LGRAPH_CPP_CLIENT_LIBRARIES} Threads::Threads) \ No newline at end of file +target_link_libraries(wpa PUBLIC Threads::Threads) diff --git a/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json b/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json deleted file mode 100644 index 06794f06d..000000000 --- a/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "schema": [ - { - "label":"BasicBlockEdge", - "type":"EDGE", - "properties" : [] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json b/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json deleted file mode 100644 index 0036a3060..000000000 --- a/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json +++ /dev/null @@ -1,47 +0,0 @@ -{ - "schema": [ - { - "label" : "SVFBasicBlock", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"STRING", - "optional":false, - "index":true - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "bb_name", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"sscc_bb_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"pred_bb_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"all_icfg_nodes_ids", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CHGEdgeSchema.json b/svf/include/Graphs/DBSchema/CHGEdgeSchema.json deleted file mode 100644 index 3f8381d47..000000000 --- a/svf/include/Graphs/DBSchema/CHGEdgeSchema.json +++ /dev/null @@ -1,17 +0,0 @@ -{ - "schema": [ - { - "label":"CHEdge", - "type":"EDGE", - "properties" : [ - { - "name" : "edge_type", - "type":"INT32", - "optional":false, - "index":false - } - ] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CHGNodeSchema.json b/svf/include/Graphs/DBSchema/CHGNodeSchema.json deleted file mode 100644 index c3841c4dd..000000000 --- a/svf/include/Graphs/DBSchema/CHGNodeSchema.json +++ /dev/null @@ -1,41 +0,0 @@ -{ - "schema": [ - { - "label" : "CHNode", - "type" : "VERTEX", - "primary" : "class_name", - "properties" : [ - { - "name" : "class_name", - "type":"STRING", - "optional":false, - "index":true - }, - { - "name" : "vtable_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "flags", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name" : "virtual_function_vectors", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json b/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json deleted file mode 100644 index e14624e2c..000000000 --- a/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json +++ /dev/null @@ -1,35 +0,0 @@ -{ - "schema": [ - { - "label":"CallGraphEdge", - "type":"EDGE", - "properties" : [ - { - "name" : "csid", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"direct_call_set", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"indirect_call_set", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json b/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json deleted file mode 100644 index 78ba5e94f..000000000 --- a/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json +++ /dev/null @@ -1,35 +0,0 @@ -{ - "schema": [ - { - "label" : "CallGraphNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"fun_name", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json b/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json deleted file mode 100644 index 0fca65c54..000000000 --- a/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json +++ /dev/null @@ -1,65 +0,0 @@ -{ - "schema": [ - { - "label" : "IntraCFGEdge", - "type" : "EDGE", - "properties" : [ - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "condition_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "branch_cond_val", - "type":"INT64", - "optional":false, - "index":false - } - ] - }, - { - "label" : "CallCFGEdge", - "type" : "EDGE", - "properties" : [ - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"call_pe_ids", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "RetCFGEdge", - "type" : "EDGE", - "properties" : [ - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ret_pe_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json b/svf/include/Graphs/DBSchema/ICFGNodeSchema.json deleted file mode 100644 index caf000d30..000000000 --- a/svf/include/Graphs/DBSchema/ICFGNodeSchema.json +++ /dev/null @@ -1,378 +0,0 @@ -{ - "schema": [ - { - "label" : "GlobalICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "IntraICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_return", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "InterICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "FunEntryICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fp_nodes", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "FunExitICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"formal_ret_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "CallICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ret_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "index":false, - "optional":false - }, - { - "name":"ap_nodes", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"called_fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_vararg", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"is_vir_call_inst", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"vtab_ptr_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"virtual_fun_idx", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_name_of_v_call", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"ind_fun_ptr_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "RetICFGNode", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"actual_ret_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"call_block_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "index":false, - "optional":false - }, - { - "name":"bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"pag_edge_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json b/svf/include/Graphs/DBSchema/PAGEdgeSchema.json deleted file mode 100644 index 7a5a251d3..000000000 --- a/svf/include/Graphs/DBSchema/PAGEdgeSchema.json +++ /dev/null @@ -1,1463 +0,0 @@ -{ - "schema": [ - { - "label" : "SVFStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - } - ] - }, - { - "label" : "AssignStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - } - ] - }, - { - "label" : "AddrStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"arr_size", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "CopyStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"copy_kind", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "StoreStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - } - ] - }, - { - "label" : "LoadStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - } - ] - }, - { - "label" : "GepStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"variant_field", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"ap_fld_idx", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"ap_gep_pointee_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ap_idx_operand_pairs", - "type":"STRING", - "optional":true, - "index":false - } - ] - }, - { - "label" : "CallPE", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"call_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_entry_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "RetPE", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"call_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_exit_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "MultiOpndStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_var_node_ids", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "PhiStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_var_node_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"op_icfg_nodes_ids", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SelectStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_var_node_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"condition_svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "CmpStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_var_node_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"predicate", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "BinaryOPStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_var_node_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"op_code", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "UnaryOPStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"op_code", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "BranchStmt", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"condition_svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"br_inst_svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"successors", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "TDForkPE", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"call_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_entry_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "RetPETDJoinPE", - "type" : "EDGE", - "properties" : [ - { - "name" : "edge_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name" : "kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name" : "edge_flag", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name" : "svf_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"bb_id", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"inst2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"var2_label_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"call_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"store_edge_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"multi_opnd_label_counter", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"call_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_exit_icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - } - ] -} - \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/PAGNodeSchema.json b/svf/include/Graphs/DBSchema/PAGNodeSchema.json deleted file mode 100644 index f3baf0d79..000000000 --- a/svf/include/Graphs/DBSchema/PAGNodeSchema.json +++ /dev/null @@ -1,1916 +0,0 @@ -{ - "schema": [ - { - "label" : "SVFVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ArgValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"cg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"arg_no", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "GepValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"base_val_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"gep_val_svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ap_fld_idx", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"ap_gep_pointee_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ap_idx_operand_pairs", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"llvm_var_inst_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "BaseObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "GepObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"base_obj_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"app_offset", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "HeapObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "StackObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "FunObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"is_decl", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"intrinsic", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"is_addr_taken", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"is_uncalled", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"is_not_ret", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"sup_var_arg", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"fun_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"real_def_fun_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"exit_bb_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"all_args_node_ids", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"reachable_bbs", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"dt_bbs_map", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"pdt_bbs_map", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"df_bbs_map", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"bb2_loop_map", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name": "bb2_p_dom_level", - "type": "STRING", - "optional": false, - "index": false - }, - { - "name":"bb2_pi_dom", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"func_annotation", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"val_name", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "FunValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"fun_obj_var_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "GlobalValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstAggValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstDataValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "BlackHoleValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstFPValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"dval", - "type":"DOUBLE", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstIntValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"zval", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"sval", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstNullPtrValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "GlobalObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstAggObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstDataObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstFPObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"dval", - "type":"FLOAT", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstIntObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"zval", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"sval", - "type":"INT64", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "ConstNullPtrObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "RetValPN", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"call_graph_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "VarArgValPN", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"call_graph_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "DummyValVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "DummyObjVar", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"in_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"out_edge_kind_to_set_map", - "type":"STRING", - "optional":true, - "index":false - }, - { - "name":"icfg_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_flags", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_max_offset_limit", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_elem_num", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"obj_type_info_byte_size", - "type":"INT32", - "optional":true, - "index":false - }, - { - "name":"source_loc", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} \ No newline at end of file diff --git a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json b/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json deleted file mode 100644 index 05719d24c..000000000 --- a/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json +++ /dev/null @@ -1,383 +0,0 @@ -{ - "schema": [ - { - "label" : "SVFPointerType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SVFIntegerType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"single_and_width", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SVFFunctionType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"ret_ty_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"params_types_vec", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SVFStructType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"stinfo_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"struct_name", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"fields_id_vec", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SVFArrayType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"stinfo_node_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"num_of_element", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"type_of_element_node_type_id", - "type":"INT32", - "optional":false, - "index":false - } - ] - }, - { - "label" : "SVFOtherType", - "type" : "VERTEX", - "primary" : "id", - "properties" : [ - { - "name" : "id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"svf_i8_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"svf_ptr_type_id", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"kind", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"is_single_val_ty", - "type":"BOOL", - "optional":false, - "index":false - }, - { - "name":"byte_size", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"repr", - "type":"STRING", - "optional":false, - "index":false - } - ] - }, - { - "label" : "StInfo", - "type" : "VERTEX", - "primary" : "st_info_id", - "properties" : [ - { - "name" : "st_info_id", - "type":"INT32", - "optional":false, - "index":true - }, - { - "name":"fld_idx_vec", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"elem_idx_vec", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"fld_idx_2_type_map", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"finfo_types", - "type":"STRING", - "optional":false, - "index":false - }, - { - "name":"stride", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"num_of_flatten_elements", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"num_of_flatten_fields", - "type":"INT32", - "optional":false, - "index":false - }, - { - "name":"flatten_element_types", - "type":"STRING", - "optional":false, - "index":false - } - ] - } - ] -} \ No newline at end of file diff --git a/svf/include/Graphs/IRGraph.h b/svf/include/Graphs/IRGraph.h index fc996c9a6..ca6f0f453 100644 --- a/svf/include/Graphs/IRGraph.h +++ b/svf/include/Graphs/IRGraph.h @@ -281,17 +281,6 @@ class IRGraph : public GenericGraph } return nullptr; } - - inline void addSVFTypes(const Set* types) - { - svfTypes.insert(types->begin(), types->end()); - } - - inline void addStInfos(const Set* stInfos) - { - this->stInfos.insert(stInfos->begin(), stInfos->end()); - } - inline const Set& getStInfos() const { return stInfos; @@ -416,4 +405,4 @@ template<> struct GenericGraphTraits : public GenericGraphTraits< }; } // End namespace llvm -#endif /* IRGRAPH_H_ */ \ No newline at end of file +#endif /* IRGRAPH_H_ */ diff --git a/svf/include/SVFIR/GraphDBClient.h b/svf/include/SVFIR/GraphDBClient.h deleted file mode 100644 index 536c6138e..000000000 --- a/svf/include/SVFIR/GraphDBClient.h +++ /dev/null @@ -1,998 +0,0 @@ -#ifndef INCLUDE_GRAPHDBCLIENT_H_ -#define INCLUDE_GRAPHDBCLIENT_H_ -#include "Graphs/CallGraph.h" -#include "Graphs/ICFGEdge.h" -#include "Graphs/ICFGNode.h" -#include "Graphs/CHG.h" -#include "SVFIR/SVFIR.h" -#include "SVFIR/SVFStatements.h" -#include "SVFIR/SVFType.h" -#include "Util/SVFUtil.h" -#include "Util/cJSON.h" -#include "lgraph/lgraph_rpc_client.h" -#include -#include - -namespace SVF -{ -class RpcClient; -class ICFGEdge; -class ICFGNode; -class CallGraphEdge; -class CallGraphNode; -class SVFType; -class StInfo; -class SVFIR; -class SVFVar; -class SVFStmt; -class SVFBasicBlock; -class BasicBlockEdge; -class BasicBlockGraph; -class CHGraph; -class CHEdge; -class CHNode; -class GraphDBClient -{ -private: - lgraph::RpcClient* connection; - - GraphDBClient() - { - const char* url = "127.0.0.1:9090"; - connection = new lgraph::RpcClient(url, "admin", "qazwsx123"); - } - - ~GraphDBClient() - { - if (connection != nullptr) - { - connection = nullptr; - } - } - -public: - static GraphDBClient& getInstance() - { - static GraphDBClient instance; - return instance; - } - - GraphDBClient(const GraphDBClient&) = delete; - GraphDBClient& operator=(const GraphDBClient&) = delete; - - lgraph::RpcClient* getConnection() - { - return connection; - } - - bool loadSchema(lgraph::RpcClient* connection, const std::string& filepath, - const std::string& dbname); - bool createSubGraph(lgraph::RpcClient* connection, - const std::string& graphname); - bool addCallGraphNode2db(lgraph::RpcClient* connection, - const CallGraphNode* node, - const std::string& dbname); - bool addCallGraphEdge2db(lgraph::RpcClient* connection, - const CallGraphEdge* edge, - const std::string& dbname); - bool addICFGNode2db(lgraph::RpcClient* connection, const ICFGNode* node, - const std::string& dbname); - bool addICFGEdge2db(lgraph::RpcClient* connection, const ICFGEdge* edge, - const std::string& dbname); - - /// pasre the directcallsIds/indirectcallsIds string to vector - std::vector stringToIds(const std::string& str); - - void insertICFG2db(const ICFG* icfg); - void insertCallGraph2db(const CallGraph* callGraph); - void insertPAG2db(const SVFIR* pag); - void insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph); - void insertSVFTypeNodeSet2db(const Set* types, - const Set* stInfos, - std::string& dbname); - - /// @brief parse the CHG and generate the insert statements for CHG nodes and edges - /// @param chg - void insertCHG2db(const CHGraph* chg); - void insertCHNode2db(lgraph::RpcClient* connection, const CHNode* node, const std::string& dbname); - void insertCHEdge2db(lgraph::RpcClient* connection, const CHEdge* edge, const std::string& dbname); - std::string getCHNodeInsertStmt(const CHNode* node); - std::string getCHEdgeInsertStmt(const CHEdge* edge); - - std::string getPAGNodeInsertStmt(const SVFVar* node); - void insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, - const std::string& dbname); - void insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* node, - const std::string& dbname); - void insertBBNode2db(lgraph::RpcClient* connection, - const SVFBasicBlock* node, const std::string& dbname); - void insertBBEdge2db(lgraph::RpcClient* connection, - const BasicBlockEdge* node, const std::string& dbname); - std::string getPAGEdgeInsertStmt(const SVFStmt* edge); - std::string getPAGNodeKindString(const SVFVar* node); - - /// parse ICFGNodes & generate the insert statement for ICFGNodes - std::string getICFGNodeKindString(const ICFGNode* node); - - cJSON* queryFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string queryStatement); - /// read SVFType from DB - void readSVFTypesFromDB(lgraph::RpcClient* connection, - const std::string& dbname, SVFIR* pag); - void addSVFTypeNodeFromDB(lgraph::RpcClient* connection, - const std::string& dbname, SVFIR* pag); - - /// read BasicBlockGraph from DB - void readBasicBlockGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname); - void readBasicBlockNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); - void readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar); - void updateBasicBlockNodes(ICFG* icfg); - - /// read ICFGNodes & ICFGEdge from DB - ICFG* buildICFGFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); - /// ICFGNodes - void readICFGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, ICFG* icfg, SVFIR* pag); - ICFGNode* parseGlobalICFGNodeFromDBResult(const cJSON* node); - ICFGNode* parseFunEntryICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); - ICFGNode* parseFunExitICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); - ICFGNode* parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); - ICFGNode* parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); - ICFGNode* parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* pag); - void parseSVFStmtsForICFGNodeFromDBResult(SVFIR* pag); - void updateRetPE4RetCFGEdge(); - void updateCallPEs4CallCFGEdge(); - - /// ICFGEdges - void readICFGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, ICFG* icfg, SVFIR* pag); - ICFGEdge* parseIntraCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); - ICFGEdge* parseCallCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); - ICFGEdge* parseRetCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg); - - // read CallGraph Nodes & CallGraphEdge from DB - CallGraph* buildCallGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); - CallGraphNode* parseCallGraphNodeFromDB(const cJSON* node); - CallGraphEdge* parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* pag, CallGraph* callGraph); - void readCallGraphNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, CallGraph* callGraph); - void readCallGraphEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag, CallGraph* callGraph); - - /// read PAGNodes from DB - void readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag); - void initialSVFPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); - void updateSVFPAGNodesAttributesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag); - void updatePAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); - void updateSVFValVarAtrributes(cJSON* properties, ValVar* var, SVFIR* pag); - void updateGepValVarAttributes(cJSON* properties, GepValVar* var, SVFIR* pag); - void updateSVFBaseObjVarAtrributes(cJSON* properties, BaseObjVar* var, SVFIR* pag); - void updateFunObjVarAttributes(cJSON* properties, FunObjVar* var, SVFIR* pag); - void loadSVFPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag); - void readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag); - void parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap); - void parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes); - - /// BasicBlockGraph toDBString() - const std::string bb2DBString(const SVFBasicBlock* bb); - const std::string bbEdge2DBString(const BasicBlockEdge* edge); - - /// CallGraph toDBString() - const std::string callGraphNode2DBString(const CallGraphNode* node); - const std::string callGraphEdge2DBString(const CallGraphEdge* edge); - - - /// ICFG toDBString() - const std::string intraCFGEdge2DBString(const IntraCFGEdge* edge); - const std::string callCFGEdge2DBString(const CallCFGEdge* edge); - const std::string retCFGEdge2DBString(const RetCFGEdge* edge); - const std::string globalICFGNode2DBString(const GlobalICFGNode* node); - const std::string intraICFGNode2DBString(const IntraICFGNode* node); - const std::string interICFGNode2DBString(const InterICFGNode* node); - const std::string funEntryICFGNode2DBString(const FunEntryICFGNode* node); - const std::string funExitICFGNode2DBString(const FunExitICFGNode* node); - const std::string retICFGNode2DBString(const RetICFGNode* node); - const std::string callICFGNode2DBString(const CallICFGNode* node); - - /// SVFType toDBString() - const std::string stInfo2DBString(const StInfo* stinfo); - const std::string SVFPointerType2DBString(const SVFPointerType* type); - const std::string SVFArrayType2DBString(const SVFArrayType* type); - const std::string SVFIntegerType2DBString(const SVFIntegerType* type); - const std::string SVFFunctionType2DBString(const SVFFunctionType* type); - const std::string SVFStructType2DBString(const SVFStructType* type); - const std::string SVFOtherType2DBString(const SVFOtherType* type); - - /// PAG toDBString() - const std::string generateSVFStmtEdgeFieldsStmt(const SVFStmt* stmt); - const std::string SVFStmt2DBString(const SVFStmt* stmt); - const std::string AssignStmt2DBString(const AssignStmt* stmt); - const std::string AddrStmt2DBString(const AddrStmt* stmt); - const std::string CopyStmt2DBString(const CopyStmt* stmt); - const std::string StoreStmt2DBString(const StoreStmt* stmt); - const std::string LoadStmt2DBString(const LoadStmt* stmt); - const std::string GepStmt2DBString(const GepStmt* stmt); - const std::string CallPE2DBString(const CallPE* stmt); - const std::string RetPE2DBString(const RetPE* stmt); - const std::string MultiOpndStmt2DBString(const MultiOpndStmt* stmt); - const std::string PhiStmt2DBString(const PhiStmt* stmt); - const std::string SelectStmt2DBString(const SelectStmt* stmt); - const std::string CmpStmt2DBString(const CmpStmt* stmt); - const std::string BinaryOPStmt2DBString(const BinaryOPStmt* stmt); - const std::string UnaryOPStmt2DBString(const UnaryOPStmt* stmt); - const std::string BranchStmt2DBString(const BranchStmt* stmt); - const std::string TDForkPE2DBString(const TDForkPE* stmt); - const std::string TDJoinPE2DBString(const TDJoinPE* stmt); - const std::string generateAssignStmtFieldsStmt(const AssignStmt* stmt) - { - return generateSVFStmtEdgeFieldsStmt(stmt); - } - const std::string generateMultiOpndStmtEdgeFieldsStmt(const MultiOpndStmt* stmt) - { - std::string stmtStr = generateSVFStmtEdgeFieldsStmt(stmt); - if (!stmt->getOpndVars().empty()) - { - stmtStr += ", op_var_node_ids:'" + extractNodesIds(stmt->getOpndVars())+"'"; - } - else - { - stmtStr += ", op_var_node_ids:''"; - } - return stmtStr; - } - - const std::string valVar2DBString(const ValVar* var); - const std::string objVar2DBString(const ObjVar* var); - const std::string argValVar2DBString(const ArgValVar* var); - const std::string gepValVar2DBString(const GepValVar* var); - const std::string baseObjVar2DBString(const BaseObjVar* var); - const std::string gepObjVar2DBString(const GepObjVar* var); - const std::string heapObjVar2DBString(const HeapObjVar* var); - const std::string stackObjVar2DBString(const StackObjVar* var); - const std::string funObjVar2DBString(const FunObjVar* var); - const std::string funValVar2DBString(const FunValVar* var); - const std::string globalValVar2DBString(const GlobalValVar* var); - const std::string constAggValVar2DBString(const ConstAggValVar* var); - const std::string constDataValVar2DBString(const ConstDataValVar* var); - const std::string blackHoleValVar2DBString(const BlackHoleValVar* var); - const std::string constFPValVar2DBString(const ConstFPValVar* var); - const std::string constIntValVar2DBString(const ConstIntValVar* var); - const std::string constNullPtrValVar2DBString(const ConstNullPtrValVar* var); - const std::string globalObjVar2DBString(const GlobalObjVar* var); - const std::string constAggObjVar2DBString(const ConstAggObjVar* var); - const std::string constDataObjVar2DBString(const ConstDataObjVar* var); - const std::string constFPObjVar2DBString(const ConstFPObjVar* var); - const std::string constIntObjVar2DBString(const ConstIntObjVar* var); - const std::string constNullPtrObjVar2DBString(const ConstNullPtrObjVar* var); - const std::string retValPN2DBString(const RetValPN* var); - const std::string varArgValPN2DBString(const VarArgValPN* var); - const std::string dummyValVar2DBString(const DummyValVar* var); - const std::string dummyObjVar2DBString(const DummyObjVar* var); - const std::string getSVFVarNodeFieldsStmt(const SVFVar* var) - { - std::string fieldsStr = ""; - fieldsStr += "id: " + std::to_string(var->getId()) + - ", svf_type_id:"+ std::to_string(var->getType()->getId()) + - ", in_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(var->getInEdgeKindToSetMap()) + - "', out_edge_kind_to_set_map:'" + pagEdgeToSetMapTyToString(var->getOutEdgeKindToSetMap()) + - "'" + var->sourceLocToDBString(); - return fieldsStr; - } - - const std::string getValVarNodeFieldsStmt(const ValVar* var) - { - std::string fieldsStr = getSVFVarNodeFieldsStmt(var); - if ( nullptr != var->getICFGNode()) - { - fieldsStr += ", icfg_node_id:" + std::to_string(var->getICFGNode()->getId()); - } - else - { - fieldsStr += ", icfg_node_id:-1"; - } - return fieldsStr; - } - - const std::string getObjVarNodeFieldsStmt(const ObjVar* var) - { - return getSVFVarNodeFieldsStmt(var); - } - - const std::string getBaseObjVarNodeFieldsStmt(const BaseObjVar* var) - { - std::string fieldsStr; - std::string icfgIDstr = ""; - if (nullptr != var->getICFGNode()) - { - icfgIDstr = - ", icfg_node_id:" + std::to_string(var->getICFGNode()->getId()); - } - else - { - icfgIDstr = ", icfg_node_id:-1"; - } - std::string objTypeInfo_byteSize_str = ""; - if (var->isConstantByteSize()) - { - objTypeInfo_byteSize_str += ", obj_type_info_byte_size:" + - std::to_string(var->getByteSizeOfObj()); - } - fieldsStr += getObjVarNodeFieldsStmt(var) + icfgIDstr + ", obj_type_info_type_id:" + - std::to_string(var->getTypeInfo()->getType()->getId()) + - ", obj_type_info_flags:" + - std::to_string(var->getTypeInfo()->getFlag()) + - ", obj_type_info_max_offset_limit:" + - std::to_string(var->getMaxFieldOffsetLimit()) + - ", obj_type_info_elem_num:" + std::to_string(var->getNumOfElements()) + - objTypeInfo_byteSize_str; - return fieldsStr; - } - - const std::string getConstDataObjVarNodeFieldsStmt(const ConstDataObjVar* var) - { - return getBaseObjVarNodeFieldsStmt(var); - } - - const std::string getConstDataValVarNodeFieldsStmt(const ConstDataValVar* var) - { - return getValVarNodeFieldsStmt(var); - } - - std::string parseNodeSourceLocation(cJSON* node) const - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return ""; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return ""; - - std::string sourceLocation = cJSON_GetObjectItem(properties, "source_loc")->valuestring; - - return sourceLocation.empty() ? "" : sourceLocation; - } - - ObjTypeInfo* parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag); - - template - std::string extractNodesIds(const Container& nodes) - { - if (nodes.empty()) - { - return ""; - } - std::ostringstream nodesIds; - auto it = nodes.begin(); - - nodesIds << (*it)->getId(); - ++it; - - for (; it != nodes.end(); ++it) - { - nodesIds << "," << (*it)->getId(); - } - - return nodesIds.str(); - } - - std::string extractFuncVectors2String(std::vector> vec) { - std::ostringstream oss; - for (size_t i = 0; i < vec.size(); ++i) { - oss << "{" << extractNodesIds(vec[i]) << "}"; - if (i + 1 != vec.size()) { - oss << ","; - } - } - return oss.str(); - } - - template - std::string extractEdgesIds(const Container& edges) - { - if (edges.empty()) - { - return ""; - } - std::ostringstream edgesIds; - auto it = edges.begin(); - - edgesIds << (*it)->getEdgeID(); - ++it; - - for (; it != edges.end(); ++it) - { - edgesIds << "," << (*it)->getEdgeID(); - } - - return edgesIds.str(); - } - - template - std::string extractIdxs(const Container& idxVec) - { - if (idxVec.empty()) - { - return ""; - } - std::ostringstream idxVecStr; - auto it = idxVec.begin(); - - idxVecStr << *it; - ++it; - - for (; it != idxVec.end(); ++it) - { - idxVecStr << "," << *it; - } - - return idxVecStr.str(); - } - - template - Container parseElements2Container(std::string& str) - { - str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); - str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); - Container idxVec; - std::istringstream ss(str); - std::string token; - - while (std::getline(ss, token, ',')) - { - if constexpr (std::is_same::value) - { - if constexpr (std::is_same>::value || - std::is_same>::value) - idxVec.push_back(std::stoi(token)); - else - idxVec.insert(std::stoi(token)); - } - else if constexpr (std::is_same::value) - { - if constexpr (std::is_same>::value || - std::is_same>::value) - idxVec.push_back(static_cast(std::stoul(token))); - else - idxVec.insert(static_cast(std::stoul(token))); - } - else - { - if constexpr (std::is_same>::value || - std::is_same>::value) - idxVec.push_back(std::stof(token)); - else - idxVec.insert(std::stof(token)); - } - } - - return idxVec; - } - - template - std::string extractSVFTypes(const Container& types) - { - if (types.empty()) - { - return ""; - } - - std::ostringstream typesStr; - auto it = types.begin(); - - - typesStr << "{" << (*it)->getId() << "}"; - ++it; - - for (; it != types.end(); ++it) - { - typesStr << "," << "{" << (*it)->getId() << "}"; - } - - return typesStr.str(); - } - - template - Container parseElementsToSVFTypeContainer(std::string& str, const Map& typeMap) - { - str.erase(std::remove(str.begin(), str.end(), '\n'), str.end()); - str.erase(std::remove(str.begin(), str.end(), '\r'), str.end()); - - Container resultContainer; - - size_t pos = 0; - while ((pos = str.find('{')) != std::string::npos) - { - size_t endPos = str.find('}', pos); - if (endPos == std::string::npos) - { - SVFUtil::outs() << "Warning: Mismatched brackets in input string\n"; - break; - } - - std::string token = str.substr(pos + 1, endPos - pos - 1); - - token.erase(token.find_last_not_of(" \t") + 1); - token.erase(0, token.find_first_not_of(" \t")); - - int typeId = std::stoi(token); - auto it = typeMap.find(typeId); - if (it != typeMap.end()) - { - resultContainer.insert(resultContainer.end(), it->second); - } - else - { - SVFUtil::outs() - << "Warning: No matching SVFType found for token '" << token - << "'\n"; - } - - str = str.substr(endPos + 1); - } - - return resultContainer; - } - - std::vector parseSVFTypes(std::string typesStr) - { - typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\n'), - typesStr.end()); - typesStr.erase(std::remove(typesStr.begin(), typesStr.end(), '\r'), - typesStr.end()); - std::vector result; - std::stringstream ss(typesStr); - std::string token; - - while (std::getline(ss, token, ',')) - { - if (!token.empty() && token.front() == '{') - { - token.erase(0, 1); - } - if (!token.empty() && token.back() == '}') - { - token.erase(token.size() - 1, 1); - } - if (!token.empty()) - { - result.push_back(std::stoi(token)); - } - } - - return result; - } - - template - std::string extractFldIdx2TypeMap(const MapType& fldIdx2TypeMap) - { - if (fldIdx2TypeMap.empty()) - { - return ""; - } - - std::ostringstream mapStr; - auto it = fldIdx2TypeMap.begin(); - - mapStr << "{" << it->first << ":" << it->second->getId() << "}"; - ++it; - - for (; it != fldIdx2TypeMap.end(); ++it) - { - mapStr << ",{" << it->first << ":" << it->second->getId() << "}"; - } - - return mapStr.str(); - } - - template - MapType parseStringToFldIdx2TypeMap(const std::string& str, const Map& typeMap) - { - MapType resultMap; - - std::string cleanedStr = str; - cleanedStr.erase(0, cleanedStr.find_first_not_of(" \t")); - cleanedStr.erase(cleanedStr.find_last_not_of(" \t") + 1); - - size_t startPos = 0; - size_t openBracePos = cleanedStr.find('{', startPos); - - while (openBracePos != std::string::npos) { - size_t closeBracePos = cleanedStr.find('}', openBracePos); - if (closeBracePos == std::string::npos) { - break; - } - - std::string token = cleanedStr.substr(openBracePos + 1, closeBracePos - openBracePos - 1); - - size_t colonPos = token.find(':'); - if (colonPos != std::string::npos) { - std::string keyStr = token.substr(0, colonPos); - std::string typeStr = token.substr(colonPos + 1); - int typeId = std::stoi(typeStr); - - u32_t key = static_cast(std::stoi(keyStr)); - - auto it = typeMap.find(typeId); - if (it != typeMap.end()) { - resultMap[key] = it->second; - } else { - SVFUtil::outs() << "Warning: No matching SVFType found for type: " << typeStr << "\n"; - } - } - - startPos = closeBracePos + 1; - openBracePos = cleanedStr.find('{', startPos); - } - - return resultMap; - } - - template - std::string extractLabelMap2String(const LabelMapType& labelMap) - { - if (labelMap->empty()) - { - return ""; - } - std::ostringstream mapStr; - - for (auto it = labelMap->begin(); it != labelMap->end(); ++it) - { - if (it != labelMap->begin()) - { - mapStr << ","; - } - mapStr << (it->first ? std::to_string(it->first->getId()) : "NULL") - << ":" << std::to_string(it->second); - } - - return mapStr.str(); - } - - template - MapType parseLabelMapFromString(const std::string& str) - { - MapType result; - if (str.empty()) return result; - - std::stringstream ss(str); - std::string pairStr; - - while (std::getline(ss, pairStr, ',')) - { - size_t colonPos = pairStr.find(':'); - if (colonPos == std::string::npos) continue; - - std::string keyStr = pairStr.substr(0, colonPos); - std::string valStr = pairStr.substr(colonPos + 1); - - int key = (keyStr == "NULL") ? -1 : std::stoi(keyStr); - int val = std::stoi(valStr); - - result[key] = val; - } - - return result; - } - - template - std::string extractBBsMapWithSet2String(const BBsMapWithSetType& bbsMap) - { - if (bbsMap->empty()) - { - return ""; - } - std::ostringstream mapStr; - auto it = bbsMap->begin(); - - for (; it != bbsMap->end(); ++it) - { - mapStr << "[" << it->first->getId() << ":"; - mapStr << extractNodesIds(it->second); - mapStr << "]"; - } - - return mapStr.str(); - } - - template - MapType parseBBsMapFromString(const std::string& str) - { - MapType result; - - using KeyType = typename MapType::key_type; - using ValueContainer = typename MapType::mapped_type; - using ValueType = typename ValueContainer::value_type; - - size_t pos = 0; - while ((pos = str.find('[', pos)) != std::string::npos) - { - size_t end = str.find(']', pos); - if (end == std::string::npos) break; - - std::string block = str.substr(pos + 1, end - pos - 1); // earse [] - pos = end + 1; - - size_t colonPos = block.find(':'); - if (colonPos == std::string::npos) continue; - - std::string keyStr = block.substr(0, colonPos); - std::string valuesStr = block.substr(colonPos + 1); - - KeyType key = static_cast(std::stoi(keyStr)); - ValueContainer values; - - if (!valuesStr.empty()) - { - std::stringstream ss(valuesStr); - std::string token; - while (std::getline(ss, token, ',')) - { - if (!token.empty()) - values.insert(values.end(), static_cast(std::stoi(token))); - } - } - - result[key] = values; - } - - return result; - } - - template - std::string extractBBsMap2String(const BBsMapType& bbsMap) - { - if (bbsMap->empty()) - { - return ""; - } - std::ostringstream mapStr; - for (const auto& pair : *bbsMap) - { - if (mapStr.tellp() != std::streampos(0)) - { - mapStr << ","; - } - if (pair.first != nullptr && pair.second != nullptr) - { - mapStr << pair.first->getId() << ":" << pair.second->getId(); - } - else if (pair.first == nullptr) - { - mapStr << "NULL:" << pair.second->getId(); - } - else if (pair.second == nullptr) - { - mapStr << pair.first->getId() << ":NULL"; - } - } - return mapStr.str(); - } - - - template - MapType parseBB2PiMapFromString(const std::string& str) - { - MapType result; - if (str.empty()) return result; - - std::stringstream ss(str); - std::string pairStr; - - while (std::getline(ss, pairStr, ',')) - { - size_t colonPos = pairStr.find(':'); - if (colonPos == std::string::npos) continue; - - std::string keyStr = pairStr.substr(0, colonPos); - std::string valStr = pairStr.substr(colonPos + 1); - - int key = (keyStr == "NULL") ? -1 : std::stoi(keyStr); - int val = (valStr == "NULL") ? -1 : std::stoi(valStr); - - result[key] = val; - } - - return result; - } - - template - std::string pagEdgeToSetMapTyToString(const MapType& map) - { - if (map.empty()) - { - return ""; - } - - std::ostringstream oss; - - for (auto it = map.begin(); it != map.end(); ++it) - { - oss << "[" << it->first << ":"; - const SVFStmt::SVFStmtSetTy& set = it->second; - for (auto setIt = set.begin(); setIt != set.end(); ++setIt) - { - if (setIt != set.begin()) - { - oss << ","; - } - oss << (*setIt)->getEdgeID(); - } - oss << "]"; - - if (std::next(it) != map.end()) - { - oss << ","; - } - } - - return oss.str(); - } - - /// Convert IdxOperandPairs to string - std::string IdxOperandPairsToString( - const AccessPath::IdxOperandPairs* idxOperandPairs) const - { - if (idxOperandPairs->empty()) - { - return ""; - } - - std::ostringstream oss; - oss << "["; - for (auto it = idxOperandPairs->begin(); it != idxOperandPairs->end(); - ++it) - { - if (it != idxOperandPairs->begin()) - { - oss << ", "; - } - oss << IdxOperandPairToString(*it); - } - oss << "]"; - return oss.str(); - } - - std::string IdxOperandPairToString( - const AccessPath::IdxOperandPair& pair) const - { - std::ostringstream oss; - if (nullptr != pair.first && nullptr != pair.second) - { - oss << "{" << pair.first->getId() << ", " << pair.second->getId() - << "}"; - return oss.str(); - } - else if (nullptr == pair.second) - { - oss << "{" << pair.first->getId() << ", NULL}"; - } - return ""; - } - - std::vector> parseIdxOperandPairsString(const std::string& str) - { - std::vector> result; - - if (str.empty() || str == "[]") - { - return result; - } - - size_t pos = 0; - std::string content = str.substr(1, str.size() - 2); // remove the outter [] - - while ((pos = content.find('{')) != std::string::npos) - { - size_t end = content.find('}', pos); - if (end == std::string::npos) - break; - - std::string pairStr = - content.substr(pos + 1, end - pos - 1); // extract the pair content - content = content.substr(end + 1); //processing the rest - - size_t comma = pairStr.find(','); - if (comma == std::string::npos) - continue; - - std::string idStr = pairStr.substr(0, comma); - std::string operandStr = pairStr.substr(comma + 1); - - // erase the spaces - idStr.erase(std::remove_if(idStr.begin(), idStr.end(), ::isspace), - idStr.end()); - operandStr.erase( - std::remove_if(operandStr.begin(), operandStr.end(), ::isspace), - operandStr.end()); - - int id = std::stoi(idStr); - result.emplace_back(id, operandStr); - } - - return result; - } - - std::string extractSuccessorsPairSet2String( - const BranchStmt::SuccAndCondPairVec* vec) - { - std::ostringstream oss; - for (auto it = vec->begin(); it != vec->end(); ++it) - { - if (it != vec->begin()) - { - oss << ","; - } - oss << (*it).first->getId() << ":" << std::to_string((*it).second); - } - - return oss.str(); - } - - std::vector> parseSuccessorsPairSetFromString(const std::string& str) - { - std::vector> result; - if (str.empty()) - return result; - - std::stringstream ss(str); - std::string pairStr; - - while (std::getline(ss, pairStr, ',')) { - size_t colonPos = pairStr.find(':'); - if (colonPos != std::string::npos) { - int first = std::stoi(pairStr.substr(0, colonPos)); - s32_t second = static_cast(std::stoi(pairStr.substr(colonPos + 1))); - result.emplace_back(first, second); - } - } - - return result; - } - - int parseBBId(const std::string& str) { - size_t pos = str.find(':'); - int number = std::stoi(str.substr(0, pos)); - return number; - } - - std::pair parseBBIdPair(const std::string& idStr) { - size_t colonPos = idStr.find(':'); - if (colonPos == std::string::npos) { - return std::make_pair(-1, -1); - } - - int functionId = std::stoi(idStr.substr(0, colonPos)); - int bbId = std::stoi(idStr.substr(colonPos + 1)); - return std::make_pair(functionId, bbId); - } - - std::string serializeAnnotations(const std::vector& annotations) - { - std::string result; - for (size_t i = 0; i < annotations.size(); ++i) - { - result += annotations[i].c_str(); - if (i < annotations.size() - 1) - result += ", "; - } - return result; - } - - std::vector deserializeAnnotations(const std::string& annotationsStr) - { - std::vector result; - std::istringstream iss(annotationsStr); - std::string token; - while (std::getline(iss, token, ',')) - { - token.erase(0, token.find_first_not_of(" \t")); - token.erase(token.find_last_not_of(" \t") + 1); - if (!token.empty()) - result.push_back(token); - } - return result; - } -}; - -} // namespace SVF - -#endif \ No newline at end of file diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index 2231b51d2..a66839fce 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -502,57 +502,15 @@ class SVFIR : public IRGraph void print(); protected: - /// Add a value (pointer) node - inline NodeID addValNodeFromDB(ValVar* node) - { - assert(node && "node cannot be nullptr."); - if (hasGNode(node->getId())) - { - ValVar* valvar = SVFUtil::cast(getGNode(node->getId())); - valvar->updateSVFValVarFromDB(node->getType(), node->getICFGNode()); - return valvar->getId(); - } - return addNode(node); - } - /// Add a memory obj node - inline NodeID addObjNodeFromDB(ObjVar* node) - { - assert(node && "node cannot be nullptr."); - if (hasGNode(node->getId())) - { - ObjVar* objVar = SVFUtil::cast(getGNode(node->getId())); - objVar->updateObjVarFromDB(node->getType()); - return objVar->getId(); - } - return addNode(node); - } - - inline NodeID addInitValNodeFromDB(ValVar* node) - { - return addValNode(node); - } - - inline NodeID addBaseObjNodeFromDB(BaseObjVar* node) + inline NodeID addBaseObjNode(BaseObjVar* node) { memToFieldsMap[node->getId()].set(node->getId()); return addObjNode(node); } - inline NodeID addDummyObjNodeFromDB(DummyObjVar* node) - { - if (idToObjTypeInfoMap().find(node->getId()) == idToObjTypeInfoMap().end()) - { - ObjTypeInfo* ti = node->getTypeInfo(); - idToObjTypeInfoMap()[node->getId()] = ti; - return addObjNode(node); - } - else - { - return addObjNode(node); - } - } + NodeID addDummyObjNode(DummyObjVar* node); - void addGepObjNodeFromDB(GepObjVar* gepObj); + NodeID addGepObjNode(GepObjVar* gepObj, NodeID base, const APOffset& apOffset); private: @@ -575,11 +533,10 @@ class SVFIR : public IRGraph inline void addFunArgs(const FunObjVar* fun, const SVFVar* arg) { FunEntryICFGNode* funEntryBlockNode = icfg->getFunEntryICFGNode(fun); - funEntryBlockNode->addFormalParms(arg); - funArgsListMap[fun].push_back(arg); + addFunArgs(funEntryBlockNode, fun, arg); } - inline void addFunArgsFromDB(FunEntryICFGNode* funEntryBlockNode, FunObjVar* fun, const SVFVar* arg) + inline void addFunArgs(FunEntryICFGNode* funEntryBlockNode, const FunObjVar* fun, const SVFVar* arg) { funEntryBlockNode->addFormalParms(arg); funArgsListMap[fun].push_back(arg); @@ -588,11 +545,10 @@ class SVFIR : public IRGraph inline void addFunRet(const FunObjVar* fun, const SVFVar* ret) { FunExitICFGNode* funExitBlockNode = icfg->getFunExitICFGNode(fun); - funExitBlockNode->addFormalRet(ret); - funRetMap[fun] = ret; + addFunRet(funExitBlockNode, fun, ret); } - inline void addFunRetFromDB(FunExitICFGNode* funExitBlockNode, FunObjVar* fun, const SVFVar* ret) + inline void addFunRet(FunExitICFGNode* funExitBlockNode, const FunObjVar* fun, const SVFVar* ret) { funExitBlockNode->addFormalRet(ret); funRetMap[fun] = ret; @@ -623,7 +579,7 @@ class SVFIR : public IRGraph /// Add a value (pointer) node inline NodeID addValNode(NodeID i, const SVFType* type, const ICFGNode* icfgNode) { - SVFVar *node = new ValVar(i, type, icfgNode, ValVar::ValNode); + ValVar *node = new ValVar(i, type, icfgNode, ValVar::ValNode); return addValNode(node); } @@ -690,9 +646,8 @@ class SVFIR : public IRGraph */ inline NodeID addHeapObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); HeapObjVar *heapObj = new HeapObjVar(i, ti, type, node); - return addObjNode(heapObj); + return addBaseObjNode(heapObj); } /** @@ -700,60 +655,52 @@ class SVFIR : public IRGraph */ inline NodeID addStackObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); StackObjVar *stackObj = new StackObjVar(i, ti, type, node); - return addObjNode(stackObj); + return addBaseObjNode(stackObj); } NodeID addFunObjNode(NodeID id, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[id].set(id); FunObjVar* funObj = new FunObjVar(id, ti, type, node); - return addObjNode(funObj); + return addBaseObjNode(funObj); } inline NodeID addConstantFPObjNode(NodeID i, ObjTypeInfo* ti, double dval, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); ConstFPObjVar* conObj = new ConstFPObjVar(i, dval, ti, type, node); - return addObjNode(conObj); + return addBaseObjNode(conObj); } inline NodeID addConstantIntObjNode(NodeID i, ObjTypeInfo* ti, const std::pair& intValue, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); ConstIntObjVar* conObj = new ConstIntObjVar(i, intValue.first, intValue.second, ti, type, node); - return addObjNode(conObj); + return addBaseObjNode(conObj); } inline NodeID addConstantNullPtrObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); ConstNullPtrObjVar* conObj = new ConstNullPtrObjVar(i, ti, type, node); - return addObjNode(conObj); + return addBaseObjNode(conObj); } inline NodeID addGlobalObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); GlobalObjVar* gObj = new GlobalObjVar(i, ti, type, node); - return addObjNode(gObj); + return addBaseObjNode(gObj); } inline NodeID addConstantAggObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); - ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, type, node); - return addObjNode(conObj); + ConstAggObjVar* conObj = new ConstAggObjVar(i, ti, type, node); + return addBaseObjNode(conObj); } inline NodeID addConstantDataObjNode(const NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); ConstDataObjVar* conObj = new ConstDataObjVar(i, ti, type, node); - return addObjNode(conObj); + return addBaseObjNode(conObj); } /// Add a unique return node for a procedure @@ -776,9 +723,8 @@ class SVFIR : public IRGraph /// Add a field-insensitive node, this method can only invoked by getFIGepObjNode NodeID addFIObjNode(NodeID i, ObjTypeInfo* ti, const SVFType* type, const ICFGNode* node) { - memToFieldsMap[i].set(i); BaseObjVar* baseObj = new BaseObjVar(i, ti, type, node); - return addObjNode(baseObj); + return addBaseObjNode(baseObj); } @@ -796,11 +742,11 @@ class SVFIR : public IRGraph { ObjTypeInfo* ti = createObjTypeInfo(type); idToObjTypeInfoMap()[i] = ti; - return addObjNode(new DummyObjVar(i, ti, nullptr, type)); + return addDummyObjNode(new DummyObjVar(i, ti, nullptr, type)); } else { - return addObjNode(new DummyObjVar(i, getObjTypeInfo(i), nullptr, type)); + return addDummyObjNode(new DummyObjVar(i, getObjTypeInfo(i), nullptr, type)); } } @@ -819,23 +765,9 @@ class SVFIR : public IRGraph //@} /// Add a value (pointer) node - inline NodeID addValNode(SVFVar *node) - { - assert(node && "node cannot be nullptr."); - assert(hasGNode(node->getId()) == false && - "This NodeID clashes here. Please check NodeIDAllocator. Switch " - "Strategy::DBUG to SEQ or DENSE"); - return addNode(node); - } + NodeID addValNode(ValVar* node); /// Add a memory obj node - inline NodeID addObjNode(SVFVar *node) - { - assert(node && "node cannot be nullptr."); - assert(hasGNode(node->getId()) == false && - "This NodeID clashes here. Please check NodeIDAllocator. Switch " - "Strategy::DBUG to SEQ or DENSE"); - return addNode(node); - } + NodeID addObjNode(ObjVar *node); /// Add a unique return node for a procedure inline NodeID addRetNode(const FunObjVar*, SVFVar *node) { @@ -855,13 +787,7 @@ class SVFIR : public IRGraph /// Add callsites inline void addCallSite(const CallICFGNode* call) { - // if (call->getId() == 9889 ||call->getId() == 9914 ||call->getId() == 9922 ||call->getId() == 9944 ||call->getId() == 10733 ||call->getId() == 10741 ||call->getId() == 10762 ||call->getId() == 10770 ) - // { - - // } else { - callSiteSet.insert(call); - // SVFUtil::outs()<< "Adding callsite: " << call->getId() << "\n"; - // } + callSiteSet.insert(call); } inline void addGepValObjFromDB(NodeID curInstID, const GepValVar* gepValvar) @@ -872,49 +798,49 @@ class SVFIR : public IRGraph //@{ /// Add Address edge AddrStmt* addAddrStmt(NodeID src, NodeID dst); - void addAddrStmtFromDB(AddrStmt* edge); + void addAddrStmt(AddrStmt* edge); /// Add Copy edge CopyStmt* addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type); - void addCopyStmtFromDB(CopyStmt* edge); + void addCopyStmt(CopyStmt* edge); /// Add phi node information PhiStmt* addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred); - void addPhiStmtFromDB(PhiStmt* edge, SVFVar* src, SVFVar* dst); + void addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst); /// Add SelectStmt SelectStmt* addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond); - void addSelectStmtFromDB(SelectStmt* edge, SVFVar* src, SVFVar* dst); + void addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge CmpStmt* addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predict); - void addCmpStmtFromDB(CmpStmt* edge, SVFVar* src, SVFVar* dst); + void addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst); /// Add Copy edge BinaryOPStmt* addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t opcode); - void addBinaryOPStmtFromDB(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst); + void addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add Unary edge UnaryOPStmt* addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode); - void addUnaryOPStmtFromDB(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst); + void addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst); /// Add BranchStmt BranchStmt* addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccAndCondPairVec& succs); - void addBranchStmtFromDB(BranchStmt* edge, SVFVar* src, SVFVar* dst); + void addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst); /// Add Load edge LoadStmt* addLoadStmt(NodeID src, NodeID dst); - void addLoadStmtFromDB(LoadStmt* edge); + void addLoadStmt(LoadStmt* edge); /// Add Store edge StoreStmt* addStoreStmt(NodeID src, NodeID dst, const ICFGNode* val); - void addStoreStmtFromDB(StoreStmt* edge, SVFVar* src, SVFVar* dst); + void addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst); /// Add Call edge CallPE* addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunEntryICFGNode* entry); - void addCallPEFromDB(CallPE* edge, SVFVar* src, SVFVar* dst); + void addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst); /// Add Return edge RetPE* addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const FunExitICFGNode* exit); - void addRetPEFromDB(RetPE* edge, SVFVar* src, SVFVar* dst); + void addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst); /// Add Gep edge GepStmt* addGepStmt(NodeID src, NodeID dst, const AccessPath& ap, bool constGep); - void addGepStmtFromDB(GepStmt* edge); + void addGepStmt(GepStmt* edge); /// Add Offset(Gep) edge GepStmt* addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap); /// Add Variant(Gep) edge diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index cb61ca36f..6f5ac0e0d 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -262,7 +262,6 @@ class SVFVar : public GenericPAGNodeTy o << node.toString(); return o; } - }; @@ -285,6 +284,7 @@ class ValVar: public SVFVar private: const ICFGNode* icfgNode; // icfgnode related to valvar + ValVar(NodeID i, const SVFType* type, PNODEK ty = ValNode) : SVFVar(i, type, ty), icfgNode(nullptr) {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -468,7 +468,6 @@ class ArgValVar: public ValVar virtual bool isPointer() const; virtual const std::string toString() const; - }; @@ -922,7 +921,6 @@ class GepObjVar: public ObjVar { return base->isPointer(); } - }; @@ -941,6 +939,7 @@ class HeapObjVar: public BaseObjVar protected: /// Constructor to create heap object var HeapObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, HeapObjNode) {} + HeapObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, PNODEK ty = HeapObjNode) : BaseObjVar(i, type, ti, ty) {} public: @@ -985,7 +984,6 @@ class HeapObjVar: public BaseObjVar } virtual const std::string toString() const; - }; @@ -1050,7 +1048,6 @@ class StackObjVar: public BaseObjVar } virtual const std::string toString() const; - }; @@ -1079,7 +1076,6 @@ class FunObjVar : public BaseObjVar { loopAndDom = ld; } - public: typedef SVFLoopAndDomInfo::BBSet BBSet; @@ -1191,7 +1187,6 @@ class FunObjVar : public BaseObjVar { return isNotRet; } - /// Returns the FunctionType inline const SVFFunctionType* getFunctionType() const { @@ -1327,7 +1322,6 @@ class FunObjVar : public BaseObjVar { return allArgs; } - inline const SVFBasicBlock* front() const { return getEntryBlock(); @@ -1355,7 +1349,6 @@ class FunObjVar : public BaseObjVar virtual bool isIsolatedNode() const; virtual const std::string toString() const; - }; class FunValVar : public ValVar { @@ -1413,7 +1406,6 @@ class FunValVar : public ValVar funObjVar = cgn; } virtual const std::string toString() const; - }; @@ -1460,7 +1452,6 @@ class GlobalValVar : public ValVar virtual const std::string toString() const; - }; class ConstAggValVar: public ValVar @@ -1515,7 +1506,6 @@ class ConstAggValVar: public ValVar } virtual const std::string toString() const; - }; @@ -1628,7 +1618,6 @@ class BlackHoleValVar : public ConstDataValVar { return "BlackHoleValVar"; } - }; class ConstFPValVar : public ConstDataValVar @@ -1687,7 +1676,6 @@ class ConstFPValVar : public ConstDataValVar } virtual const std::string toString() const; - }; class ConstIntValVar : public ConstDataValVar @@ -1754,7 +1742,6 @@ class ConstIntValVar : public ConstDataValVar } virtual const std::string toString() const; - }; class ConstNullPtrValVar : public ConstDataValVar @@ -1809,7 +1796,6 @@ class ConstNullPtrValVar : public ConstDataValVar } virtual const std::string toString() const; - }; class GlobalObjVar : public BaseObjVar @@ -1865,7 +1851,6 @@ class GlobalObjVar : public BaseObjVar virtual const std::string toString() const; - }; class ConstAggObjVar : public BaseObjVar @@ -2195,7 +2180,6 @@ class ConstNullPtrObjVar : public ConstDataObjVar return false; } virtual const std::string toString() const; - }; /* * Unique Return node of a procedure @@ -2257,7 +2241,6 @@ class RetValPN : public ValVar const std::string getValueName() const; virtual const std::string toString() const; - }; /* @@ -2319,7 +2302,6 @@ class VarArgValPN : public ValVar return true; } virtual const std::string toString() const; - }; /* @@ -2375,7 +2357,6 @@ class DummyValVar: public ValVar } virtual const std::string toString() const; - }; /* @@ -2441,7 +2422,6 @@ class DummyObjVar: public BaseObjVar } virtual const std::string toString() const; - }; } // End namespace SVF diff --git a/svf/lib/Graphs/CallGraph.cpp b/svf/lib/Graphs/CallGraph.cpp index 11b31cba2..4b53b8de4 100644 --- a/svf/lib/Graphs/CallGraph.cpp +++ b/svf/lib/Graphs/CallGraph.cpp @@ -32,7 +32,6 @@ #include "SVFIR/SVFIR.h" #include "Util/Options.h" #include "Util/SVFUtil.h" -#include "SVFIR/GraphDBClient.h" #include #include "Util/Options.h" diff --git a/svf/lib/Graphs/ICFG.cpp b/svf/lib/Graphs/ICFG.cpp index ebdf1f2cd..c66c944d7 100644 --- a/svf/lib/Graphs/ICFG.cpp +++ b/svf/lib/Graphs/ICFG.cpp @@ -31,7 +31,6 @@ #include "Graphs/CallGraph.h" #include "SVFIR/SVFIR.h" #include -#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; diff --git a/svf/lib/Graphs/IRGraph.cpp b/svf/lib/Graphs/IRGraph.cpp index 6c73ba1bb..c8f577f5a 100644 --- a/svf/lib/Graphs/IRGraph.cpp +++ b/svf/lib/Graphs/IRGraph.cpp @@ -268,12 +268,7 @@ bool IRGraph::addEdge(SVFVar* src, SVFVar* dst, SVFStmt* edge) SVFStmt* IRGraph::hasNonlabeledEdge(SVFVar* src, SVFVar* dst, SVFStmt::PEDGEK kind) { SVFStmt edge(src,dst,kind, false); - SVFStmt::SVFStmtSetTy::iterator it = KindToSVFStmtSetMap[kind].find(&edge); - if (it != KindToSVFStmtSetMap[kind].end()) - { - return *it; - } - return nullptr; + return hasEdge(&edge, kind); } /*! diff --git a/svf/lib/SVFIR/GraphDBClient.cpp b/svf/lib/SVFIR/GraphDBClient.cpp deleted file mode 100644 index a882163d3..000000000 --- a/svf/lib/SVFIR/GraphDBClient.cpp +++ /dev/null @@ -1,5042 +0,0 @@ -#include "SVFIR/GraphDBClient.h" -#include "SVFIR/SVFVariables.h" - -using namespace SVF; - -Map id2funObjVarsMap; -Set basicBlocks; -Map id2RetICFGNodeMap; -Map id2CallPEMap; -Map id2RetPEMap; -Map callCFGEdge2CallPEStrMap; -Map retCFGEdge2RetPEStrMap; -Map icfgNode2StmtsStrMap; -Map edgeId2SVFStmtMap; -Map bb2AllICFGNodeIdstrMap; - -bool GraphDBClient::loadSchema(lgraph::RpcClient* connection, - const std::string& filepath, - const std::string& dbname) -{ - if (nullptr != connection) - { - SVFUtil::outs() << "load schema from file:" << filepath << "\n"; - std::string result; - bool ret = connection->ImportSchemaFromFile(result, filepath, dbname); - if (!ret) - { - SVFUtil::outs() << dbname<< "Warining: Schema load failed:" << result << "\n"; - } - return ret; - } - return false; -} - -// create a new graph name CallGraph in db -bool GraphDBClient::createSubGraph(lgraph::RpcClient* connection, const std::string& graphname) -{ - ///TODO: graph name should be configurable - if (nullptr != connection) - { - std::string result; - connection->CallCypher(result, "CALL dbms.graph.deleteGraph('"+graphname+"')"); - bool ret = connection->CallCypherToLeader(result, "CALL dbms.graph.createGraph('"+graphname+"')"); - if (!ret) - { - SVFUtil::outs() - << "Warining: Failed to create Graph callGraph:" << result << "\n"; - } - } - return false; -} - -bool GraphDBClient::addICFGEdge2db(lgraph::RpcClient* connection, - const ICFGEdge* edge, - const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement; - if(const IntraCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) - { - queryStatement = intraCFGEdge2DBString(cfgEdge); - } - else if (const CallCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) - { - queryStatement = callCFGEdge2DBString(cfgEdge); - } - else if (const RetCFGEdge* cfgEdge = SVFUtil::dyn_cast(edge)) - { - queryStatement = retCFGEdge2DBString(cfgEdge); - } - else - { - assert("unknown icfg edge type?"); - return false; - } - // SVFUtil::outs() << "ICFGEdge Query Statement:" << queryStatement << "\n"; - std::string result; - if (queryStatement.empty()) - { - return false; - } - bool ret = connection->CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add ICFG edge to db " << dbname << " " - << result << "\n"; - } - return ret; - - } - return false; -} - -bool GraphDBClient::addICFGNode2db(lgraph::RpcClient* connection, - const ICFGNode* node, - const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement; - if(const GlobalICFGNode* globalICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = globalICFGNode2DBString(globalICFGNode); - } - else if (const IntraICFGNode* intraICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = intraICFGNode2DBString(intraICFGNode); - } - else if (const FunEntryICFGNode* funEntryICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = funEntryICFGNode2DBString(funEntryICFGNode); - } - else if (const FunExitICFGNode* funExitICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = funExitICFGNode2DBString(funExitICFGNode); - } - else if (const CallICFGNode* callICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = callICFGNode2DBString(callICFGNode); - } - else if (const RetICFGNode* retICFGNode = SVFUtil::dyn_cast(node)) - { - queryStatement = retICFGNode2DBString(retICFGNode); - } - else - { - assert("unknown icfg node type?"); - return false; - } - - // SVFUtil::outs()<<"ICFGNode Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add icfg node to db " << dbname << " " - << result << "\n"; - } - return ret; - } - return false; -} - -bool GraphDBClient::addCallGraphNode2db(lgraph::RpcClient* connection, - const CallGraphNode* node, - const std::string& dbname) -{ - if (nullptr != connection) - { - const std::string queryStatement = callGraphNode2DBString(node); - // SVFUtil::outs()<<"CallGraph Node Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add callGraph node to db " << dbname << " " - << result << "\n"; - } - return ret; - } - return false; -} - -bool GraphDBClient::addCallGraphEdge2db(lgraph::RpcClient* connection, - const CallGraphEdge* edge, - const std::string& dbname) -{ - if (nullptr != connection) - { - const std::string queryStatement = callGraphEdge2DBString(edge); - // SVFUtil::outs() << "Call Graph Edge Insert Query:" << queryStatement << "\n"; - std::string result; - bool ret = connection->CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add callgraph edge to db " << dbname << " " - << result << "\n"; - } - // SVFUtil::outs()<<"CallGraph Edge Insert Query:"< GraphDBClient::stringToIds(const std::string& str) -{ - std::vector ids; - std::istringstream iss(str); - std::string token; - while (std::getline(iss, token, ',')) - { - ids.push_back(std::stoi(token)); - } - return ids; -} - -std::string GraphDBClient::getICFGNodeKindString(const ICFGNode* node) -{ - if(SVFUtil::isa(node)) - { - return "GlobalICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "FunEntryICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "FunExitICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "CallICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "RetICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "InterICFGNode"; - } - else if (SVFUtil::isa(node)) - { - return "IntraICFGNode"; - } - else - { - assert("unknown icfg node type?"); - return ""; - } -} - -void GraphDBClient::insertCHG2db(const CHGraph* chg) -{ - std::string chgNodePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; - std::string chgEdgePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/CHGEdgeSchema.json"; - // add all CHG Node & Edge to DB - if (nullptr != connection) - { - // create a new graph name CHG in db - createSubGraph(connection, "CHG"); - // load schema for CHG - loadSchema(connection, chgEdgePath.c_str(), "CHG"); - loadSchema(connection, chgNodePath.c_str(), "CHG"); - std::vector edges; - for (auto it = chg->begin(); it != chg->end(); ++it) - { - CHNode* node = it->second; - insertCHNode2db(connection, node, "CHG"); - for (auto edgeIter = node->OutEdgeBegin(); - edgeIter != node->OutEdgeEnd(); ++edgeIter) - { - CHEdge* edge = *edgeIter; - edges.push_back(edge); - } - } - for (const auto& edge : edges) - { - insertCHEdge2db(connection, edge, "CHG"); - } - } -} - -void GraphDBClient::insertCHNode2db(lgraph::RpcClient* connection, const CHNode* node, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement; - if (SVFUtil::isa(node)) - { - queryStatement = getCHNodeInsertStmt(SVFUtil::cast(node)); - } - else - { - assert("unknown CHG node type?"); - return ; - } - // SVFUtil::outs()<<"CHNode Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add CHG node to db " << dbname << " " - << result << "\n"; - } - } -} - -std::string GraphDBClient::getCHNodeInsertStmt(const CHNode* node) -{ - const std::string queryStatement ="CREATE (n:CHNode {class_name:'" + node->getName() + "'" + - ", vtable_id: " + std::to_string(node->getVTable()->getId()) + - ", flags:'" + std::to_string(node->getFlags()) +"'" + - ", virtual_function_vectors:'" + extractFuncVectors2String(node->getVirtualFunctionVectors()) + "'" + - + "})"; - return queryStatement; -} - -std::string GraphDBClient::getCHEdgeInsertStmt(const CHEdge* edge) -{ - const std::string queryStatement = - "MATCH (n:CHNode{class_name:'"+edge->getSrcNode()->getName()+"'}), (m:CHNode{class_name:'"+edge->getDstNode()->getName()+"'}) WHERE n.class_name = '" + - edge->getSrcNode()->getName() + - "' AND m.class_name = '" + edge->getDstNode()->getName() + - "' CREATE (n)-[r:CHEdge{edge_type:" + std::to_string(edge->getEdgeType()) + - "}]->(m)"; - return queryStatement; -} - -void GraphDBClient::insertCHEdge2db(lgraph::RpcClient* connection, const CHEdge* edge, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement; - if (SVFUtil::isa(edge)) - { - queryStatement = getCHEdgeInsertStmt(SVFUtil::cast(edge)); - } - else - { - assert("unknown CHG edge type?"); - return ; - } - // SVFUtil::outs()<<"CHEdge Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add CHG edge to db " << dbname << " " - << result << "\n"; - } - } -} - -void GraphDBClient::insertICFG2db(const ICFG* icfg) -{ - // add all ICFG Node & Edge to DB - if (nullptr != connection) - { - // create a new graph name ICFG in db - createSubGraph(connection, "ICFG"); - // load schema for CallGraph - std::string ICFGNodePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/ICFGNodeSchema.json"; - std::string ICFGEdgePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/ICFGEdgeSchema.json"; - loadSchema(connection, ICFGNodePath.c_str(), "ICFG"); - loadSchema(connection, ICFGEdgePath.c_str(), "ICFG"); - std::vector edges; - for (auto it = icfg->begin(); it != icfg->end(); ++it) - { - ICFGNode* node = it->second; - addICFGNode2db(connection, node, "ICFG"); - for (auto edgeIter = node->OutEdgeBegin(); - edgeIter != node->OutEdgeEnd(); ++edgeIter) - { - ICFGEdge* edge = *edgeIter; - edges.push_back(edge); - } - } - for (auto edge : edges) - { - addICFGEdge2db(connection, edge, "ICFG"); - } - } -} - -void GraphDBClient::insertCallGraph2db(const CallGraph* callGraph) -{ - - std::string callGraphNodePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/CallGraphNodeSchema.json"; - std::string callGraphEdgePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/CallGraphEdgeSchema.json"; - // add all CallGraph Node & Edge to DB - if (nullptr != connection) - { - // create a new graph name CallGraph in db - createSubGraph(connection, "CallGraph"); - // load schema for CallGraph - SVF::GraphDBClient::getInstance().loadSchema( - connection, - callGraphEdgePath, - "CallGraph"); - SVF::GraphDBClient::getInstance().loadSchema( - connection, - callGraphNodePath, - "CallGraph"); - std::vector edges; - for (const auto& item : *callGraph) - { - const CallGraphNode* node = item.second; - addCallGraphNode2db(connection, node, "CallGraph"); - for (CallGraphEdge::CallGraphEdgeSet::iterator iter = - node->OutEdgeBegin(); - iter != node->OutEdgeEnd(); ++iter) - { - const CallGraphEdge* edge = *iter; - edges.push_back(edge); - } - } - for (const auto& edge : edges) - { - addCallGraphEdge2db(connection, edge, "CallGraph"); - } - - } else { - SVFUtil::outs() << "No DB connection, skip inserting CallGraph to DB\n"; - } -} - -void GraphDBClient::insertSVFTypeNodeSet2db(const Set* types, const Set* stInfos, std::string& dbname) -{ - if (nullptr != connection) - { - // create a new graph name SVFType in db - createSubGraph(connection, "SVFType"); - // load schema for SVFType - loadSchema(connection, SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/SVFTypeNodeSchema.json", "SVFType"); - - // load & insert each svftype node to db - for (const auto& ty : *types) - { - std::string queryStatement; - if (const SVFPointerType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFPointerType2DBString(svfType); - } - else if (const SVFIntegerType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFIntegerType2DBString(svfType); - } - else if (const SVFFunctionType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFFunctionType2DBString(svfType); - } - else if (const SVFStructType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFStructType2DBString(svfType); - } - else if (const SVFArrayType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFArrayType2DBString(svfType); - } - else if (const SVFOtherType* svfType = SVFUtil::dyn_cast(ty)) - { - queryStatement = SVFOtherType2DBString(svfType); - } - else - { - assert("unknown SVF type?"); - return ; - } - - // SVFUtil::outs()<<"SVFType Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add SVFType node to db " << dbname << " " - << result << "\n"; - } - - } - - // load & insert each stinfo node to db - for(const StInfo* stInfo : *stInfos) - { - // insert stinfo node to db - std::string queryStatement = stInfo2DBString(stInfo); - // SVFUtil::outs()<<"StInfo Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add StInfo node to db " << dbname << " " - << result << "\n"; - } - } - } - -} - -void GraphDBClient::insertBasicBlockGraph2db(const BasicBlockGraph* bbGraph) -{ - if (nullptr != connection) - { - std::vector edges; - for (auto& bb: *bbGraph) - { - SVFBasicBlock* node = bb.second; - insertBBNode2db(connection, node, "BasicBlockGraph"); - for (auto iter = node->OutEdgeBegin(); iter != node->OutEdgeEnd(); ++iter) - { - edges.push_back(*iter); - } - } - for (const BasicBlockEdge* edge : edges) - { - insertBBEdge2db(connection, edge, "BasicBlockGraph"); - } - } -} - -void GraphDBClient::insertBBEdge2db(lgraph::RpcClient* connection, const BasicBlockEdge* edge, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement = bbEdge2DBString(edge); - // SVFUtil::outs()<<"BBEdge Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add BB edge to db " << dbname - << " " << result << "\n"; - } - } - } -} - -void GraphDBClient::insertBBNode2db(lgraph::RpcClient* connection, const SVFBasicBlock* node, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement = bb2DBString(node); - // SVFUtil::outs()<<"BBNode Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add BB node to db " << dbname - << " " << result << "\n"; - } - } - } -} - -void GraphDBClient::insertPAG2db(const PAG* pag) -{ - std::string pagNodePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/PAGNodeSchema.json"; - std::string pagEdgePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/PAGEdgeSchema.json"; - std::string bbNodePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/BasicBlockNodeSchema.json"; - std::string bbEdgePath = - SVF_SOURCE_DIR "/svf/include/Graphs/DBSchema/BasicBlockEdgeSchema.json"; - - // add all PAG Node & Edge to DB - if (nullptr != connection) - { - // create a new graph name PAG in db - createSubGraph(connection, "PAG"); - // create a new graph name BasicBlockGraph in db - createSubGraph(connection, "BasicBlockGraph"); - // load schema for PAG - SVF::GraphDBClient::getInstance().loadSchema(connection, pagEdgePath, - "PAG"); - SVF::GraphDBClient::getInstance().loadSchema(connection, pagNodePath, - "PAG"); - // load schema for PAG - SVF::GraphDBClient::getInstance().loadSchema(connection, bbEdgePath, - "BasicBlockGraph"); - SVF::GraphDBClient::getInstance().loadSchema(connection, bbNodePath, - "BasicBlockGraph"); - - std::vector edges; - for (auto it = pag->begin(); it != pag->end(); ++it) - { - SVFVar* node = it->second; - insertPAGNode2db(connection, node, "PAG"); - for (auto edgeIter = node->OutEdgeBegin(); - edgeIter != node->OutEdgeEnd(); ++edgeIter) - { - SVFStmt* edge = *edgeIter; - edges.push_back(edge); - } - } - for (auto edge : edges) - { - insertPAGEdge2db(connection, edge, "PAG"); - } - } - else - { - SVFUtil::outs() << "No DB connection, skip inserting CallGraph to DB\n"; - } -} - -void GraphDBClient::insertPAGEdge2db(lgraph::RpcClient* connection, const SVFStmt* edge, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement = getPAGEdgeInsertStmt(edge); - // SVFUtil::outs()<<"PAGEdge Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add PAG edge to db " << dbname - << " " << result << "\n"; - } - } - } -} - -std::string GraphDBClient::getPAGEdgeInsertStmt(const SVFStmt* edge) -{ - std::string queryStatement = ""; - if(const TDForkPE* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = TDForkPE2DBString(svfStmt); - } - else if(const TDJoinPE* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = TDJoinPE2DBString(svfStmt); - } - else if(const CallPE* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = CallPE2DBString(svfStmt); - } - else if(const RetPE* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = RetPE2DBString(svfStmt); - } - else if(const GepStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = GepStmt2DBString(svfStmt); - } - else if(const LoadStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = LoadStmt2DBString(svfStmt); - } - else if(const StoreStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = StoreStmt2DBString(svfStmt); - } - else if(const CopyStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = CopyStmt2DBString(svfStmt); - } - else if(const AddrStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = AddrStmt2DBString(svfStmt); - } - else if(const AssignStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = AssignStmt2DBString(svfStmt); - } - else if(const PhiStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = PhiStmt2DBString(svfStmt); - } - else if(const SelectStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = SelectStmt2DBString(svfStmt); - } - else if(const CmpStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = CmpStmt2DBString(svfStmt); - } - else if(const BinaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = BinaryOPStmt2DBString(svfStmt); - } - else if(const MultiOpndStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = MultiOpndStmt2DBString(svfStmt); - } - else if(const UnaryOPStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = UnaryOPStmt2DBString(svfStmt); - } - else if(const BranchStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = BranchStmt2DBString(svfStmt); - } - else if(const SVFStmt* svfStmt = SVFUtil::dyn_cast(edge)) - { - queryStatement = SVFStmt2DBString(svfStmt); - } - else - { - assert("unknown SVFStmt type?"); - } - return queryStatement; -} - -void GraphDBClient::insertPAGNode2db(lgraph::RpcClient* connection, const SVFVar* node, const std::string& dbname) -{ - if (nullptr != connection) - { - std::string queryStatement = getPAGNodeInsertStmt(node); - // SVFUtil::outs()<<"PAGNode Insert Query:"<CallCypher(result, queryStatement, dbname); - if (!ret) - { - SVFUtil::outs() << "Warining: Failed to add PAG node to db " << dbname - << " " << result << "\n"; - } - } - } -} - -std::string GraphDBClient::getPAGNodeInsertStmt(const SVFVar* node) -{ - std::string queryStatement = ""; - if(const ConstNullPtrValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constNullPtrValVar2DBString(svfVar); - } - else if(const ConstIntValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constIntValVar2DBString(svfVar); - } - else if(const ConstFPValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constFPValVar2DBString(svfVar); - } - else if(const BlackHoleValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = blackHoleValVar2DBString(svfVar); - } - else if(const ConstDataValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constDataValVar2DBString(svfVar); - } - else if(const RetValPN* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = retValPN2DBString(svfVar); - } - else if(const VarArgValPN* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = varArgValPN2DBString(svfVar); - } - else if(const DummyValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = dummyValVar2DBString(svfVar); - } - else if(const ConstAggValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constAggValVar2DBString(svfVar); - } - else if(const GlobalValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = globalValVar2DBString(svfVar); - } - else if(const FunValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = funValVar2DBString(svfVar); - } - else if(const GepValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = gepValVar2DBString(svfVar); - } - else if(const ArgValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = argValVar2DBString(svfVar); - } - else if(const ValVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = valVar2DBString(svfVar); - } - else if(const ConstNullPtrObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constNullPtrObjVar2DBString(svfVar); - } - else if(const ConstIntObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constIntObjVar2DBString(svfVar); - } - else if(const ConstFPObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constFPObjVar2DBString(svfVar); - } - else if(const ConstDataObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constDataObjVar2DBString(svfVar); - } - else if(const DummyObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = dummyObjVar2DBString(svfVar); - } - else if(const ConstAggObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = constAggObjVar2DBString(svfVar); - } - else if(const GlobalObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = globalObjVar2DBString(svfVar); - } - else if(const FunObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = funObjVar2DBString(svfVar); - if ( nullptr != svfVar->getBasicBlockGraph()) - { - insertBasicBlockGraph2db(svfVar->getBasicBlockGraph()); - } - } - else if(const StackObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = stackObjVar2DBString(svfVar); - } - else if(const HeapObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = heapObjVar2DBString(svfVar); - } - else if(const BaseObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = baseObjVar2DBString(svfVar); - } - else if(const GepObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = gepObjVar2DBString(svfVar); - } - else if(const ObjVar* svfVar = SVFUtil::dyn_cast(node)) - { - queryStatement = objVar2DBString(svfVar); - } - else - { - assert("unknown SVFVar type?"); - } - return queryStatement; -} - -std::string GraphDBClient::getPAGNodeKindString(const SVFVar* node) -{ - if(SVFUtil::isa(node)) - { - return "ConstNullPtrValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstIntValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstFPValVar"; - } - else if(SVFUtil::isa(node)) - { - return "BlackHoleValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstDataValVar"; - } - else if(SVFUtil::isa(node)) - { - return "RetValPN"; - } - else if(SVFUtil::isa(node)) - { - return "VarArgValPN"; - } - else if(SVFUtil::isa(node)) - { - return "DummyValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstAggValVar"; - } - else if(SVFUtil::isa(node)) - { - return "GlobalValVar"; - } - else if(SVFUtil::isa(node)) - { - return "FunValVar"; - } - else if(SVFUtil::isa(node)) - { - return "GepValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ArgValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ValVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstNullPtrObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstIntObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstFPObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstDataObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "DummyObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "ConstAggObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "GlobalObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "FunObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "StackObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "HeapObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "BaseObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "GepObjVar"; - } - else if(SVFUtil::isa(node)) - { - return "ObjVar"; - } - - assert("unknown SVFVar node type?"); - return "SVFVar"; - -} - -void GraphDBClient::readSVFTypesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Build SVF types from DB....\n"; - addSVFTypeNodeFromDB(connection, dbname, pag); -} - -void GraphDBClient::addSVFTypeNodeFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - // parse all SVFType - std::string queryStatement = "MATCH (node) WHERE NOT 'StInfo' IN labels(node) return node"; - - Map svfTypeMap; - Map stInfoMap; - // Map> svfTypeKind2SVFTypesMap; - Map> svfi8AndPtrTypeMap; - Map> functionRetTypeSetMap; - Map> functionParamsTypeSetMap; - Map> stInfoId2SVFTypeMap; - Map> elementTyepsMap; - Map> structType2FieldsTypeIdMap; - - cJSON* root = queryFromDB(connection, dbname, queryStatement); - cJSON* node; - if (nullptr != root) - { - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - - std::string label = cJSON_GetObjectItem(data, "label")->valuestring; - - SVFType* type = nullptr; - int i8Type = - cJSON_GetObjectItem(properties, "svf_i8_type_id")->valueint; - int ptrType = - cJSON_GetObjectItem(properties, "svf_ptr_type_id")->valueint; - bool svt = cJSON_IsTrue( - cJSON_GetObjectItem(properties, "is_single_val_ty")); - int byteSize = - cJSON_GetObjectItem(properties, "byte_size")->valueint; - int typeId = - cJSON_GetObjectItem(properties, "id")->valueint; - - if (label == "SVFPointerType") - { - type = new SVFPointerType(typeId, byteSize, svt); - } - else if (label == "SVFIntegerType") - { - cJSON* single_and_width_Json = - cJSON_GetObjectItem(properties, "single_and_width"); - short single_and_width = - (short)cJSON_GetNumberValue(single_and_width_Json); - type = new SVFIntegerType(typeId, byteSize, svt, single_and_width); - } - else if (label == "SVFFunctionType") - { - SVFFunctionType* funType = new SVFFunctionType(typeId, svt, byteSize); - type = funType; - int retTypeId = cJSON_GetObjectItem(properties, "ret_ty_node_id") ->valueint; - auto it = svfTypeMap.find(retTypeId); - if (it != svfTypeMap.end()) - { - funType->setReturnType(it->second); - } - else - { - functionRetTypeSetMap[retTypeId].insert(funType); - } - std::string paramsTypes = cJSON_GetObjectItem(properties, "params_types_vec")->valuestring; - if (!paramsTypes.empty()) - { - functionParamsTypeSetMap[funType] = parseSVFTypes(paramsTypes); - } - } - else if (label == "SVFOtherType") - { - std::string repr = - cJSON_GetObjectItem(properties, "repr")->valuestring; - type = new SVFOtherType(typeId, svt, byteSize, repr); - } - else if (label == "SVFStructType") - { - std::string name = cJSON_GetObjectItem(properties, "struct_name")->valuestring; - SVFStructType* structType = new SVFStructType(typeId, svt, byteSize, name); - type = structType; - std::string fieldTypesStr = cJSON_GetObjectItem(properties, "fields_id_vec")->valuestring; - if (!fieldTypesStr.empty()) - { - structType2FieldsTypeIdMap[structType] = parseSVFTypes(fieldTypesStr); - } - int stInfoID = cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; - auto it = stInfoMap.find(stInfoID); - if (it != stInfoMap.end()) - { - type->setTypeInfo(it->second); - } - else - { - stInfoId2SVFTypeMap[stInfoID].insert(type); - } - } - else if (label == "SVFArrayType") - { - int numOfElement = cJSON_GetObjectItem(properties, "num_of_element")->valueint; - SVFArrayType* arrayType = new SVFArrayType(typeId, svt, byteSize, numOfElement); - type = arrayType; - int stInfoID = cJSON_GetObjectItem(properties, "stinfo_node_id")->valueint; - auto stInfoIter = stInfoMap.find(stInfoID); - if (stInfoIter != stInfoMap.end()) - { - type->setTypeInfo(stInfoIter->second); - } - else - { - stInfoId2SVFTypeMap[stInfoID].insert(type); - } - int typeOfElementId = cJSON_GetObjectItem(properties,"type_of_element_node_type_id")->valueint; - auto tyepIter = svfTypeMap.find(typeOfElementId); - if (tyepIter != svfTypeMap.end()) - { - arrayType->setTypeOfElement(tyepIter->second); - } - else - { - elementTyepsMap[typeOfElementId].insert(arrayType); - } - } - svfTypeMap.emplace(typeId, type); - // svfTypeKind2SVFTypesMap[type->getSVFTyKind()].insert(type); - svfi8AndPtrTypeMap[type] = std::make_pair(i8Type, ptrType); - } - cJSON_Delete(root); - } - - // parse all StInfo - queryStatement = "MATCH (node:StInfo) return node"; - root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - - u32_t id = static_cast(cJSON_GetObjectItem(properties, "st_info_id")->valueint); - std::string fld_idx_vec = cJSON_GetObjectItem(properties, "fld_idx_vec")->valuestring; - std::vector fldIdxVec = parseElements2Container>(fld_idx_vec); - - std::string elem_idx_vec = cJSON_GetObjectItem(properties, "elem_idx_vec")->valuestring; - std::vector elemIdxVec = parseElements2Container>(elem_idx_vec); - - std::string fld_idx_2_type_map = cJSON_GetObjectItem(properties, "fld_idx_2_type_map")->valuestring; - Map fldIdx2TypeMap = parseStringToFldIdx2TypeMap>(fld_idx_2_type_map, svfTypeMap); - - std::string finfo_types = cJSON_GetObjectItem(properties, "finfo_types")->valuestring; - std::vector finfo = parseElementsToSVFTypeContainer>(finfo_types, svfTypeMap); - - u32_t stride = static_cast(cJSON_GetObjectItem(properties, "stride")->valueint); - u32_t num_of_flatten_elements = static_cast(cJSON_GetObjectItem(properties, "num_of_flatten_elements")->valueint); - u32_t num_of_flatten_fields = static_cast(cJSON_GetObjectItem(properties, "num_of_flatten_fields")->valueint); - std::string flatten_element_types =cJSON_GetObjectItem(properties, "flatten_element_types")->valuestring; - std::vector flattenElementTypes =parseElementsToSVFTypeContainer>(flatten_element_types, svfTypeMap); - StInfo* stInfo =new StInfo(id, fldIdxVec, elemIdxVec, fldIdx2TypeMap, finfo,stride, num_of_flatten_elements,num_of_flatten_fields, flattenElementTypes); - stInfoMap[id] = stInfo; - } - cJSON_Delete(root); - } - - for (auto& [retTypeId, types]:functionRetTypeSetMap) - { - auto retTypeIter = svfTypeMap.find(retTypeId); - if (retTypeIter != svfTypeMap.end()) - { - for (auto& type: types) - { - type->setReturnType(retTypeIter->second); - } - } - else - { - SVFUtil::outs() - << "Warning: No matching RetType found for typeId: " << retTypeId << "\n"; - } - } - - for (auto& [funType, paramsVec]:functionParamsTypeSetMap) - { - for (const int param : paramsVec) - { - auto paramTypeIter = svfTypeMap.find(param); - if (paramTypeIter != svfTypeMap.end()) - { - funType->addParamType(paramTypeIter->second); - } - else - { - SVFUtil::outs()<<"Warning: No matching paramType found for typeID: " - << param << "\n"; - } - } - } - - for (auto& [structType, fieldTypes]:structType2FieldsTypeIdMap) - { - for (const int fieldTypeId : fieldTypes) - { - auto fieldTypeIter = svfTypeMap.find(fieldTypeId); - if (fieldTypeIter != svfTypeMap.end()) - { - structType->addFieldsType(fieldTypeIter->second); - } - else - { - SVFUtil::outs()<<"Warning: No matching fieldType found for typeID: " - << fieldTypeId << "\n"; - } - } - } - - for (auto&[stInfoId, types] : stInfoId2SVFTypeMap) - { - auto stInfoIter = stInfoMap.find(stInfoId); - if (stInfoIter != stInfoMap.end()) - { - for (SVFType* type: types) - { - type->setTypeInfo(stInfoIter->second); - if (SVFUtil::isa(type) && stInfoIter->second->getNumOfFlattenFields() > pag->maxStSize) - { - pag->maxStSize = stInfoIter->second->getNumOfFlattenFields(); - pag->maxStruct = type; - } - } - } - else - { - SVFUtil::outs()<<"Warning: No matching StInfo found for id: " - << stInfoId << "\n"; - } - } - - for (auto& [elementTypesId, arrayTypes]:elementTyepsMap) - { - auto elementTypeIter = svfTypeMap.find(elementTypesId); - if (elementTypeIter != svfTypeMap.end()) - { - for (SVFArrayType* type : arrayTypes) - { - type->setTypeOfElement(elementTypeIter->second); - } - } - else - { - SVFUtil::outs()<<"Warning: No matching elementType found for typeId: " - << elementTypesId << "\n"; - } - } - - for (auto& [svfType, pair]:svfi8AndPtrTypeMap) - { - int svfi8Type = pair.first; - int svfptrType = pair.second; - auto i8Type = svfTypeMap.find(svfi8Type); - auto ptrType = svfTypeMap.find(svfptrType); - if (i8Type!=svfTypeMap.end()) - { - svfType->setSVFInt8Type(i8Type->second); - } - if (ptrType!= svfTypeMap.end()) - { - svfType->setSVFPtrType(ptrType->second); - } - } - for (auto& [typeId, type] : svfTypeMap) - { - pag->addTypeInfo(type); - } - for (auto& [id, stInfo]: stInfoMap) - { - pag->addStInfo(stInfo); - } -} - -void GraphDBClient::updateRetPE4RetCFGEdge() -{ - if (retCFGEdge2RetPEStrMap.size() > 0) - { - for (auto& [edge, id] : retCFGEdge2RetPEStrMap) - { - if (nullptr != edge && id != -1) - { - auto it = id2RetPEMap.find(id); - if (it != id2RetPEMap.end()) - { - RetPE* retPE = it->second; - edge->addRetPE(retPE); - } - else - { - SVFUtil::outs() << "Warning[updateRetPE4RetCFGEdge]: No matching RetPE found for id: " << id << "\n"; - } - } - } - } -} - -void GraphDBClient::updateCallPEs4CallCFGEdge() -{ - if (callCFGEdge2CallPEStrMap.size() > 0) - { - for (auto& [edge, ids] : callCFGEdge2CallPEStrMap) - { - if (nullptr != edge && !ids.empty()) - { - std::vector idVec = parseElements2Container>(ids); - for (int id : idVec) - { - auto it = id2CallPEMap.find(id); - if (it != id2CallPEMap.end()) - { - CallPE* callPE = it->second; - edge->addCallPE(callPE); - } - else - { - SVFUtil::outs() << "Warning[updateCallPEs4CallCFGEdge]: No matching CallPE found for id: " << id << "\n"; - } - } - } - } - } -} - -void GraphDBClient::loadSVFPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Loading SVF PAG edges from DB....\n"; - readPAGEdgesFromDB(connection, dbname, "AddrStmt", pag); - readPAGEdgesFromDB(connection, dbname, "CopyStmt", pag); - readPAGEdgesFromDB(connection, dbname, "StoreStmt", pag); - readPAGEdgesFromDB(connection, dbname, "LoadStmt", pag); - readPAGEdgesFromDB(connection, dbname, "GepStmt", pag); - readPAGEdgesFromDB(connection, dbname, "CallPE", pag); - readPAGEdgesFromDB(connection, dbname, "RetPE", pag); - readPAGEdgesFromDB(connection, dbname, "PhiStmt", pag); - readPAGEdgesFromDB(connection, dbname, "SelectStmt", pag); - readPAGEdgesFromDB(connection, dbname, "CmpStmt", pag); - readPAGEdgesFromDB(connection, dbname, "BinaryOPStmt", pag); - readPAGEdgesFromDB(connection, dbname, "UnaryOPStmt", pag); - readPAGEdgesFromDB(connection, dbname, "BranchStmt", pag); - readPAGEdgesFromDB(connection, dbname, "TDForkPE", pag); - readPAGEdgesFromDB(connection, dbname, "RetPETDJoinPE", pag); - - updateCallPEs4CallCFGEdge(); - updateRetPE4RetCFGEdge(); - SVFUtil::outs()<< "Loading SVF PAG edges from DB done....\n"; - -} - -void GraphDBClient::readPAGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, SVFIR* pag) -{ - int skip = 0; - int limit = 1000; - while (true) - { - // SVFUtil::outs() << "Loading SVF PAG edges from DB, edge type: " << edgeType << ", skip: " << skip << ", limit: " << limit << "\n"; - std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if ( nullptr == root) - { - break; - } - else - { - cJSON* edge; - cJSON_ArrayForEach(edge, root) - { - cJSON* data = cJSON_GetObjectItem(edge, "edge"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - - // parse src SVFVar & dst SVFVar - int src_id = cJSON_GetObjectItem(data,"src")->valueint; - int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; - SVFVar* srcNode = pag->getGNode(src_id); - SVFVar* dstNode = pag->getGNode(dst_id); - if (nullptr == srcNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching src SVFVar found for id: " << src_id << "\n"; - continue; - } - if( nullptr == dstNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching dst SVFVar found for id: " << dst_id << "\n"; - continue; - } - - int edge_id = cJSON_GetObjectItem(properties,"edge_id")->valueint; - int svf_var_node_id = cJSON_GetObjectItem(properties,"svf_var_node_id")->valueint; - SVFVar* value = nullptr; - if (svf_var_node_id != -1) - { - value = pag->getGNode(svf_var_node_id); - } - int icfg_node_id = cJSON_GetObjectItem(properties,"icfg_node_id")->valueint; - ICFGNode* icfgNode = nullptr; - if (icfg_node_id != -1) - { - icfgNode = pag->getICFG()->getICFGNode(icfg_node_id); - } - - std::string bb_id = cJSON_GetObjectItem(properties,"bb_id")->valuestring; - SVFBasicBlock* bb = nullptr; - if (!bb_id.empty()) - { - std::pair pair = parseBBIdPair(bb_id); - if (pair.first != -1 && pair.second != -1) - { - FunObjVar* fun = SVFUtil::dyn_cast(pag->getGNode(pair.first)); - if (nullptr != fun) - { - bb = fun->getBasicBlockGraph()->getGNode(pair.second); - if (nullptr == bb) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching BB found for id: " << bb_id << "\n"; - continue; - } - } - } - } - - int call_edge_label_counter = cJSON_GetObjectItem(properties,"call_edge_label_counter")->valueint; - int store_edge_label_counter = cJSON_GetObjectItem(properties,"store_edge_label_counter")->valueint; - int multi_opnd_label_counter = cJSON_GetObjectItem(properties,"multi_opnd_label_counter")->valueint; - s64_t edgeFlag = static_cast(cJSON_GetObjectItem(properties,"edge_flag")->valueint); - - SVFStmt* stmt = nullptr; - - if (edgeType == "AddrStmt") - { - stmt = new AddrStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); - std::string arr_size = cJSON_GetObjectItem(properties,"arr_size")->valuestring; - AddrStmt* addrStmt = SVFUtil::cast(stmt); - if (!arr_size.empty()) - { - Set arrSizeVec = parseElements2Container>(arr_size); - for (int varId : arrSizeVec) - { - SVFVar* var = pag->getGNode(varId); - if (nullptr != var) - { - addrStmt->addArrSize(var); - } - else - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFVar found for id: " << varId << " when processing AddrStmt:"<addAddrStmtFromDB(addrStmt); - } - else if (edgeType == "CopyStmt") - { - int copy_kind = cJSON_GetObjectItem(properties,"copy_kind")->valueint; - stmt = new CopyStmt(srcNode, dstNode, edgeFlag, edge_id, value, copy_kind, icfgNode ); - CopyStmt* copyStmt = SVFUtil::cast(stmt); - pag->addCopyStmtFromDB(copyStmt); - } - else if (edgeType == "StoreStmt") - { - stmt = new StoreStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); - StoreStmt* storeStmt = SVFUtil::cast(stmt); - pag->addStoreStmtFromDB(storeStmt, srcNode, dstNode); - } - else if (edgeType == "LoadStmt") - { - stmt = new LoadStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode); - LoadStmt* loadStmt = SVFUtil::cast(stmt); - pag->addLoadStmtFromDB(loadStmt); - } - else if (edgeType == "GepStmt") - { - s64_t fldIdx = cJSON_GetObjectItem(properties, "ap_fld_idx")->valueint; - if (fldIdx == -1) - { - fldIdx = 0; - } - bool variant_field = cJSON_IsTrue(cJSON_GetObjectItem(properties,"variant_field")); - int ap_gep_pointee_type_id = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_id")->valueint; - const SVFType* gepPointeeType = nullptr; - if (ap_gep_pointee_type_id != -1) - { - gepPointeeType = pag->getSVFType(ap_gep_pointee_type_id); - } - AccessPath* ap = nullptr; - if (nullptr != gepPointeeType) - { - ap = new AccessPath(fldIdx, gepPointeeType); - } - else - { - ap = new AccessPath(fldIdx); - if (ap_gep_pointee_type_id != -1) - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFType found for ap_gep_pointee_type_id: " << ap_gep_pointee_type_id << " when updating GepStmt:"<valuestring) - { - ap_idx_operand_pairs = ap_idx_operand_pairs_node->valuestring; - } - parseAPIdxOperandPairsString(ap_idx_operand_pairs, pag, ap); - - stmt = new GepStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, *ap, variant_field); - GepStmt* gepStmt = SVFUtil::cast(stmt); - pag->addGepStmtFromDB(gepStmt); - } - else if (edgeType == "CallPE") - { - int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; - int fun_entry_icfg_node_id = cJSON_GetObjectItem(properties,"fun_entry_icfg_node_id")->valueint; - const CallICFGNode* callICFGNode = nullptr; - const FunEntryICFGNode* funEntryICFGNode = nullptr; - if (call_icfg_node_id != -1) - { - callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); - if (nullptr == callICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; - continue; - } - } - if (fun_entry_icfg_node_id != -1) - { - funEntryICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_entry_icfg_node_id)); - if (nullptr == funEntryICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunEntryICFGNode found for id: " << fun_entry_icfg_node_id << "\n"; - continue; - } - } - stmt = new CallPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); - CallPE* callPE = SVFUtil::cast(stmt); - pag->addCallPEFromDB(callPE, srcNode, dstNode); - id2CallPEMap[edge_id] = callPE; - } - else if (edgeType == "TDForkPE") - { - int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; - int fun_entry_icfg_node_id = cJSON_GetObjectItem(properties,"fun_entry_icfg_node_id")->valueint; - const CallICFGNode* callICFGNode = nullptr; - const FunEntryICFGNode* funEntryICFGNode = nullptr; - if (call_icfg_node_id != -1) - { - callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); - if (nullptr == callICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; - continue; - } - } - if (fun_entry_icfg_node_id != -1) - { - funEntryICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_entry_icfg_node_id)); - if (nullptr == funEntryICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunEntryICFGNode found for id: " << fun_entry_icfg_node_id << "\n"; - continue; - } - } - stmt = new TDForkPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funEntryICFGNode); - TDForkPE* forkPE = SVFUtil::cast(stmt); - pag->addCallPEFromDB(forkPE, srcNode, dstNode); - id2CallPEMap[edge_id] = forkPE; - } - else if (edgeType == "RetPE") - { - int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; - int fun_exit_icfg_node_id = cJSON_GetObjectItem(properties,"fun_exit_icfg_node_id")->valueint; - const CallICFGNode* callICFGNode = nullptr; - const FunExitICFGNode* funExitICFGNode = nullptr; - if (call_icfg_node_id != -1) - { - callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); - if (nullptr == callICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; - continue; - } - } - if (fun_exit_icfg_node_id != -1) - { - funExitICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_exit_icfg_node_id)); - if (nullptr == funExitICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunExitICFGNode found for id: " << fun_exit_icfg_node_id << "\n"; - continue; - } - } - stmt = new RetPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode,callICFGNode, funExitICFGNode); - RetPE* retPE = SVFUtil::cast(stmt); - pag->addRetPEFromDB(retPE, srcNode, dstNode); - id2RetPEMap[edge_id] = retPE; - } - else if (edgeType == "RetPETDJoinPE") - { - int call_icfg_node_id = cJSON_GetObjectItem(properties,"call_icfg_node_id")->valueint; - int fun_exit_icfg_node_id = cJSON_GetObjectItem(properties,"fun_exit_icfg_node_id")->valueint; - const CallICFGNode* callICFGNode = nullptr; - const FunExitICFGNode* funExitICFGNode = nullptr; - if (call_icfg_node_id != -1) - { - callICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(call_icfg_node_id)); - if (nullptr == callICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching CallICFGNode found for id: " << call_icfg_node_id << "\n"; - continue; - } - } - if (fun_exit_icfg_node_id != -1) - { - funExitICFGNode = SVFUtil::dyn_cast(pag->getICFG()->getGNode(fun_exit_icfg_node_id)); - if (nullptr == funExitICFGNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching FunExitICFGNode found for id: " << fun_exit_icfg_node_id << "\n"; - continue; - } - } - stmt = new TDJoinPE(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, callICFGNode, funExitICFGNode); - TDJoinPE* joinPE = SVFUtil::cast(stmt); - pag->addRetPEFromDB(joinPE, srcNode, dstNode); - id2RetPEMap[edge_id] = joinPE; - } - else if (edgeType == "PhiStmt") - { - std::vector opVarNodes; - std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; - parseOpVarString(op_var_node_ids, pag, opVarNodes); - stmt = new PhiStmt(srcNode, dstNode, edgeFlag, edge_id, value, icfgNode, opVarNodes); - PhiStmt* phiStmt = SVFUtil::cast(stmt); - std::string op_icfg_nodes_ids = cJSON_GetObjectItem(properties, "op_icfg_nodes_ids")->valuestring; - if (!op_icfg_nodes_ids.empty()) - { - std::vector opICFGNodeIds = parseElements2Container>(op_icfg_nodes_ids); - std::vector opICFGNodes; - for (int icfgNodeId : opICFGNodeIds) - { - ICFGNode* opICFGNode = pag->getICFG()->getGNode(icfgNodeId); - if (nullptr != opICFGNode) - { - opICFGNodes.push_back(opICFGNode); - } - else - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << icfgNodeId << "\n"; - } - } - phiStmt->setOpICFGNodeVec(opICFGNodes); - } - pag->addPhiStmtFromDB(phiStmt, srcNode, dstNode); - } - else if (edgeType == "SelectStmt") - { - std::vector opVarNodes; - std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; - parseOpVarString(op_var_node_ids, pag, opVarNodes); - int condition_svf_var_node_id = cJSON_GetObjectItem(properties, "condition_svf_var_node_id")->valueint; - SVFVar* condition = pag->getGNode(condition_svf_var_node_id); - stmt = new SelectStmt(srcNode, dstNode, edgeFlag, edge_id, condition, value, icfgNode, opVarNodes); - SelectStmt* selectStmt = SVFUtil::cast(stmt); - pag->addSelectStmtFromDB(selectStmt, srcNode, dstNode); - } - else if (edgeType == "CmpStmt") - { - std::vector opVarNodes; - std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; - parseOpVarString(op_var_node_ids, pag, opVarNodes); - u32_t predicate = cJSON_GetObjectItem(properties, "predicate")->valueint; - stmt = new CmpStmt(srcNode, dstNode, edgeFlag, edge_id, value, predicate, icfgNode, opVarNodes); - CmpStmt* cmpStmt = SVFUtil::cast(stmt); - pag->addCmpStmtFromDB(cmpStmt, srcNode, dstNode); - } - else if (edgeType == "BinaryOPStmt") - { - std::vector opVarNodes; - std::string op_var_node_ids = cJSON_GetObjectItem(properties, "op_var_node_ids")->valuestring; - parseOpVarString(op_var_node_ids, pag, opVarNodes); - u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; - stmt = new BinaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode, opVarNodes); - BinaryOPStmt* binaryOpStmt = SVFUtil::cast(stmt); - pag->addBinaryOPStmtFromDB(binaryOpStmt, srcNode, dstNode); - } - else if (edgeType == "UnaryOPStmt") - { - u32_t op_code = cJSON_GetObjectItem(properties, "op_code")->valueint; - stmt = new UnaryOPStmt(srcNode, dstNode, edgeFlag, edge_id, value, op_code, icfgNode); - UnaryOPStmt* unaryOpStmt = SVFUtil::cast(stmt); - pag->addUnaryOPStmtFromDB(unaryOpStmt, srcNode, dstNode); - } - else if (edgeType == "BranchStmt") - { - int condition_svf_var_node_id = cJSON_GetObjectItem(properties, "condition_svf_var_node_id")->valueint; - int br_inst_svf_var_node_id = cJSON_GetObjectItem(properties, "br_inst_svf_var_node_id")->valueint; - const SVFVar* condition = pag->getGNode(condition_svf_var_node_id); - const SVFVar* brInst = pag->getGNode(br_inst_svf_var_node_id); - if (condition == nullptr) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching condition SVFVar found for id: " << condition_svf_var_node_id << "\n"; - continue; - } - if (brInst == nullptr) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching brInst SVFVar found for id: " << br_inst_svf_var_node_id << "\n"; - continue; - } - std::string successorsStr = cJSON_GetObjectItem(properties, "successors")->valuestring; - std::vector> successorsIdVec = parseSuccessorsPairSetFromString(successorsStr); - std::vector> successors; - for (auto& pair : successorsIdVec) - { - const ICFGNode* succ = pag->getICFG()->getGNode(pair.first); - if (nullptr != succ) - { - successors.push_back(std::make_pair(succ, pair.second)); - } - else - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << pair.first << "\n"; - } - } - stmt = new BranchStmt(srcNode, dstNode, edgeFlag, edge_id, value, successors, condition, brInst, icfgNode); - BranchStmt* branchStmt = SVFUtil::cast(stmt); - pag->addBranchStmtFromDB(branchStmt, srcNode, dstNode); - } - stmt->setBasicBlock(bb); - stmt->setCallEdgeLabelCounter(static_cast(call_edge_label_counter)); - stmt->setStoreEdgeLabelCounter(static_cast(store_edge_label_counter)); - stmt->setMultiOpndLabelCounter(static_cast(multi_opnd_label_counter)); - std::string inst2_label_map; - cJSON* inst2_label_map_item = cJSON_GetObjectItem(properties,"inst2_label_map"); - if (nullptr != inst2_label_map_item->valuestring) - { - inst2_label_map = inst2_label_map_item->valuestring; - } - else { - inst2_label_map = ""; - } - std::string var2_label_map; - cJSON* var2_label_map_item = cJSON_GetObjectItem(properties,"var2_label_map"); - if (nullptr != var2_label_map_item->valuestring) - { - var2_label_map = var2_label_map_item->valuestring; - } - else { - var2_label_map = ""; - } - Map inst2_label_map_ids = parseLabelMapFromString>(inst2_label_map); - Map var2_label_map_ids = parseLabelMapFromString>(var2_label_map); - if (!inst2_label_map_ids.empty()) - { - for (auto& [id, label] : inst2_label_map_ids) - { - const ICFGNode* icfgNode = nullptr; - if (id != -1) - { - icfgNode = pag->getICFG()->getGNode(id); - if (nullptr == icfgNode) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching ICFGNode found for id: " << id << " when parsing inst2_label_map_ids\n"; - } - } - stmt->addInst2Labeled(icfgNode, label); - } - } - if (!var2_label_map_ids.empty()) - { - for (auto& [id, label] : var2_label_map_ids) - { - const SVFVar* var = nullptr; - if (id != -1) - { - var = pag->getGNode(id); - if (nullptr == var) - { - SVFUtil::outs() << "Warning: [readPAGEdgesFromDB] No matching SVFVar found for id: " << id << " when parsing var2_label_map_ids\n"; - } - } - stmt->addVar2Labeled(var, label); - } - } - skip += 1; - edgeId2SVFStmtMap[stmt->getEdgeID()] = stmt; - } - cJSON_Delete(root); - } - } -} - -void GraphDBClient::parseOpVarString(std::string& op_var_node_ids, SVFIR* pag, std::vector& opVarNodes) -{ - if (!op_var_node_ids.empty()) - { - std::vector opVarNodeIds = parseElements2Container>(op_var_node_ids); - for (int varId : opVarNodeIds) - { - SVFVar* var = pag->getGNode(varId); - if (nullptr != var) - { - opVarNodes.push_back(var); - } - else - { - SVFUtil::outs() << "Warning: [parseOpVarString] No matching SVFVar found for id: " << varId << "\n"; - } - } - } -} - -void GraphDBClient::initialSVFPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Initial SVF PAG nodes from DB....\n"; - readPAGNodesFromDB(connection, dbname, "ValVar", pag); - readPAGNodesFromDB(connection, dbname, "ObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ArgValVar", pag); - readPAGNodesFromDB(connection, dbname, "GepValVar", pag); - readPAGNodesFromDB(connection, dbname, "BaseObjVar", pag); - readPAGNodesFromDB(connection, dbname, "GepObjVar", pag); - readPAGNodesFromDB(connection, dbname, "HeapObjVar", pag); - readPAGNodesFromDB(connection, dbname, "StackObjVar", pag); - readPAGNodesFromDB(connection, dbname, "FunObjVar", pag); - readPAGNodesFromDB(connection, dbname, "FunValVar", pag); - readPAGNodesFromDB(connection, dbname, "GlobalValVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstAggValVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstDataValVar", pag); - readPAGNodesFromDB(connection, dbname, "BlackHoleValVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstFPValVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstIntValVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstNullPtrValVar", pag); - readPAGNodesFromDB(connection, dbname, "GlobalObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstAggObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstDataObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstFPObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstIntObjVar", pag); - readPAGNodesFromDB(connection, dbname, "ConstNullPtrObjVar", pag); - readPAGNodesFromDB(connection, dbname, "RetValPN", pag); - readPAGNodesFromDB(connection, dbname, "VarArgValPN", pag); - readPAGNodesFromDB(connection, dbname, "DummyValVar", pag); - readPAGNodesFromDB(connection, dbname, "DummyObjVar", pag); -} - -void GraphDBClient::updatePAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Updating SVF PAG nodes from DB....\n"; - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ArgValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "GepValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "BaseObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "GepObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "HeapObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "StackObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "FunObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "FunValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "GlobalValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstAggValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstDataValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "BlackHoleValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstFPValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstIntValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstNullPtrValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "GlobalObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstAggObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstDataObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstFPObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstIntObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "ConstNullPtrObjVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "RetValPN", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "VarArgValPN", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "DummyValVar", pag); - updateSVFPAGNodesAttributesFromDB(connection, dbname, "DummyObjVar", pag); -} - -void GraphDBClient::updateSVFValVarAtrributes(cJSON* properties, ValVar* var, SVFIR* pag) -{ - int icfg_node_id = cJSON_GetObjectItem(properties, "icfg_node_id")->valueint; - if (icfg_node_id != -1) - { - ICFGNode* icfgNode = pag->getICFG()->getGNode(icfg_node_id); - if (nullptr != icfgNode) - { - var->updateSVFValVarFromDB(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFValVarAtrributes] No matching ICFGNode found for id: " << icfg_node_id << " when update SVFVar:"<getId()<<"\n"; - } - } -} - -void GraphDBClient::updateSVFBaseObjVarAtrributes(cJSON* properties, BaseObjVar* var, SVFIR* pag) -{ - int icfg_node_id = cJSON_GetObjectItem(properties, "icfg_node_id")->valueint; - if (icfg_node_id != -1) - { - ICFGNode* icfgNode = pag->getICFG()->getGNode(icfg_node_id); - if (nullptr != icfgNode) - { - var->setICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFValVarAtrributes] No matching ICFGNode found for id: " << icfg_node_id << " when update SVFVar:"<getId()<<"\n"; - } - } -} - -void GraphDBClient::updateFunObjVarAttributes(cJSON* properties, FunObjVar* var, SVFIR* pag) -{ - int real_def_fun_node_id = cJSON_GetObjectItem(properties, "real_def_fun_node_id")->valueint; - const FunObjVar* realDefFunNode = id2funObjVarsMap[real_def_fun_node_id]; - if (nullptr != realDefFunNode) - { - var->setRelDefFun(realDefFunNode); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching FunObjVar found for id: " << real_def_fun_node_id <<" when updating FunObjVar:"<getId()<< "\n"; - } - - int exit_bb_id = cJSON_GetObjectItem(properties, "exit_bb_id")->valueint; - if (exit_bb_id != -1) - { - SVFBasicBlock* exitBB = var->getBasicBlockGraph()->getGNode(exit_bb_id); - if (nullptr != exitBB) - { - var->updateExitBlock(exitBB); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << exit_bb_id <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - - SVFLoopAndDomInfo* loopAndDom = new SVFLoopAndDomInfo(); - var->setLoopAndDomInfo(loopAndDom); - - std::string reachable_bbs = cJSON_GetObjectItem(properties, "reachable_bbs")->valuestring; - std::string dt_bbs_map = cJSON_GetObjectItem(properties, "dt_bbs_map")->valuestring; - std::string pdt_bbs_map = cJSON_GetObjectItem(properties, "pdt_bbs_map")->valuestring; - std::string df_bbs_map = cJSON_GetObjectItem(properties, "df_bbs_map")->valuestring; - std::string bb2_loop_map = cJSON_GetObjectItem(properties, "bb2_loop_map")->valuestring; - std::string bb2_p_dom_level = cJSON_GetObjectItem(properties, "bb2_p_dom_level")->valuestring; - std::string bb2_pi_dom = cJSON_GetObjectItem(properties, "bb2_pi_dom")->valuestring; - - if (!reachable_bbs.empty()) - { - std::vector BBListVec = parseElements2Container>(reachable_bbs); - std::vector reachableBBs; - for (auto& bbId : BBListVec) - { - SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); - if (nullptr != bb) - { - reachableBBs.push_back(bb); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - loopAndDom->setReachableBBs(reachableBBs); - } - - if (!dt_bbs_map.empty()) - { - Map> dtBBsMap; - - Map> dt_bbs_map_ids = parseBBsMapFromString>>(dt_bbs_map); - for (auto& [bbId, bbSetIds] : dt_bbs_map_ids) - { - SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); - if (nullptr != bb) - { - Set dtBBSet; - for (auto& bbSetId : bbSetIds) - { - SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); - if (nullptr != bbSet) - { - dtBBSet.insert(bbSet); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - dtBBsMap[bb] = dtBBSet; - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - loopAndDom->setDomTreeMap(dtBBsMap); - } - - if (!pdt_bbs_map.empty()) - { - Map> pdtBBsMap; - - Map> pdt_bbs_map_ids = parseBBsMapFromString>>(pdt_bbs_map); - for (auto& [bbId, bbSetIds] : pdt_bbs_map_ids) - { - SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); - if (nullptr != bb) - { - Set pdtBBSet; - for (auto& bbSetId : bbSetIds) - { - SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); - if (nullptr != bbSet) - { - pdtBBSet.insert(bbSet); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - pdtBBsMap[bb] = pdtBBSet; - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - loopAndDom->setPostDomTreeMap(pdtBBsMap); - } - - if (!df_bbs_map.empty()) - { - Map> dfBBsMap; - - Map> df_bbs_map_ids = parseBBsMapFromString>>(df_bbs_map); - for (auto& [bbId, bbSetIds] : df_bbs_map_ids) - { - SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); - if (nullptr != bb) - { - Set dfBBSet; - for (auto& bbSetId : bbSetIds) - { - SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); - if (nullptr != bbSet) - { - dfBBSet.insert(bbSet); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - dfBBsMap[bb] = dfBBSet; - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - loopAndDom->setDomFrontierMap(dfBBsMap); - } - - if (!bb2_loop_map.empty()) - { - Map> bb2LoopMap; - - Map> bb2_loop_map_ids = parseBBsMapFromString>>(bb2_loop_map); - for (auto& [bbId, bbSetIds] : bb2_loop_map_ids) - { - SVFBasicBlock* bb = var->getBasicBlockGraph()->getGNode(bbId); - if (nullptr != bb) - { - std::vector loopBBs; - for (auto& bbSetId : bbSetIds) - { - SVFBasicBlock* bbSet = var->getBasicBlockGraph()->getGNode(bbSetId); - if (nullptr != bbSet) - { - loopBBs.push_back(bbSet); - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbSetId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - bb2LoopMap[bb] = loopBBs; - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - loopAndDom->setBB2LoopMap(bb2LoopMap); - } - - if (!bb2_p_dom_level.empty()) - { - Map bb2PdomLevel; - Map bb2_p_dom_level_ids = parseLabelMapFromString>(bb2_p_dom_level); - for (auto& [bbId, value] : bb2_p_dom_level_ids) - { - SVFBasicBlock* bb = nullptr; - if (bbId != -1) - { - bb = var->getBasicBlockGraph()->getGNode(bbId); - } - if (nullptr != bb) - { - bb2PdomLevel[bb] = value; - } - else - { - SVFUtil::outs() << "Warning: [updateFunObjVarAttributes] No matching BasicBlock found for id: " << bbId <<" when updating FunObjVar:"<getId()<< "\n"; - } - } - - loopAndDom->setBB2PdomLevel(bb2PdomLevel); - } - - if (!bb2_pi_dom.empty()) - { - Map bb2PiDom; - - Map bb2_pi_dom_ids = parseBB2PiMapFromString>(bb2_pi_dom); - for (auto& [key,value] : bb2_pi_dom_ids) - { - SVFBasicBlock* keyBB = nullptr; - SVFBasicBlock* valueBB = nullptr; - if (key != -1) - { - keyBB = var->getBasicBlockGraph()->getGNode(key); - } - if (value != -1) - { - valueBB = var->getBasicBlockGraph()->getGNode(value); - } - bb2PiDom[keyBB] = valueBB; - } - loopAndDom->setBB2PIdom(bb2PiDom); - } -} -void GraphDBClient::updateGepValVarAttributes(cJSON* properties, GepValVar* var, SVFIR* pag) -{ - int base_val_id = cJSON_GetObjectItem(properties, "base_val_id")->valueint; - ValVar* baseVal = SVFUtil::dyn_cast(pag->getGNode(base_val_id)); - if (nullptr != baseVal) - { - var->setBaseNode(baseVal); - } - else - { - SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching ValVar found for id: " - << base_val_id << " when updating GepValVar:" << var->getId() - << "\n"; - } - s64_t fldIdx = cJSON_GetObjectItem(properties, "ap_fld_idx")->valueint; - int ap_gep_pointee_type_id = cJSON_GetObjectItem(properties, "ap_gep_pointee_type_id")->valueint; - const SVFType* gepPointeeType = nullptr; - if (ap_gep_pointee_type_id != -1) - { - gepPointeeType = pag->getSVFType(ap_gep_pointee_type_id); - } - AccessPath* ap = nullptr; - if (nullptr != gepPointeeType) - { - ap = new AccessPath(fldIdx, gepPointeeType); - } - else - { - ap = new AccessPath(fldIdx); - if (ap_gep_pointee_type_id != -1) - SVFUtil::outs() << "Warning: [updateGepValVarAttributes] No matching SVFType found for ap_gep_pointee_type_id: " << ap_gep_pointee_type_id << " when updating GepValVar:"<getId()<< "\n"; - } - - cJSON* ap_idx_operand_pairs_node = cJSON_GetObjectItem(properties, "ap_idx_operand_pairs"); - std::string ap_idx_operand_pairs = ""; - if (nullptr != ap_idx_operand_pairs_node && nullptr != ap_idx_operand_pairs_node->valuestring) - { - ap_idx_operand_pairs = ap_idx_operand_pairs_node->valuestring; - } - parseAPIdxOperandPairsString(ap_idx_operand_pairs, pag, ap); - var->setAccessPath(ap); - int llvm_var_inst_id = cJSON_GetObjectItem(properties, "llvm_var_inst_id")->valueint; - pag->addGepValObjFromDB(llvm_var_inst_id, var); -} - -void GraphDBClient::parseAPIdxOperandPairsString(const std::string& ap_idx_operand_pairs, SVFIR* pag, AccessPath* ap) -{ - if (!ap_idx_operand_pairs.empty()) - { - std::vector> pairVec = parseIdxOperandPairsString(ap_idx_operand_pairs); - for(auto& pair : pairVec) - { - int varId = pair.first; - std::string typeIdStr = pair.second; - const SVFType* type; - if (typeIdStr != "NULL") - { - int typeId = std::stoi(typeIdStr); - type = pag->getSVFType(typeId); - if (nullptr == type) - { - SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching SVFType found for type: " << typeIdStr << " when parsing IdxOperandPair\n"; - } - } - else - { - type = nullptr; - } - const SVFVar* var = pag->getGNode(varId); - if (nullptr != var) - { - std::pair pair = std::make_pair(var, type); - ap->addIdxOperandPair(pair); - } - else - { - SVFUtil::outs() << "Warning: [parseAPIdxOperandPairsString] No matching ValVar found for id: " << varId <<" when parsing IdxOperandPair \n"; - } - } - } -} - -void GraphDBClient::updateSVFPAGNodesAttributesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string result; - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+ std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* node; - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - if (nodeType == "ConstNullPtrValVar") - { - ConstNullPtrValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstIntValVar") - { - ConstIntValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstFPValVar") - { - ConstFPValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ArgValVar") - { - ArgValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ArgValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - int cg_node_id = cJSON_GetObjectItem(properties, "cg_node_id")->valueint; - FunObjVar* cgNode = id2funObjVarsMap[cg_node_id]; - if (nullptr != cgNode) - { - var->addCGNodeFromDB(cgNode); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << cg_node_id <<" when updating ArgValVar:"<< id << "\n"; - } - } - else if (nodeType == "BlackHoleValVar") - { - BlackHoleValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BlackHoleValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstDataValVar") - { - ConstDataValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "RetValPN") - { - RetValPN* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching RetValPN found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; - FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; - if (nullptr != callGraphNode) - { - var->setCallGraphNode(callGraphNode); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating RetValPN:"<(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching VarArgValPN found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - int call_graph_node_id = cJSON_GetObjectItem(properties, "call_graph_node_id")->valueint; - FunObjVar* callGraphNode = id2funObjVarsMap[call_graph_node_id]; - if (nullptr != callGraphNode) - { - var->setCallGraphNode(callGraphNode); - pag->varargFunObjSymMap[callGraphNode] = var->getId(); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << call_graph_node_id <<" when updating VarArgValPN:"<(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstAggValVar") - { - ConstAggValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "GlobalValVar") - { - GlobalValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "FunValVar") - { - FunValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - int fun_obj_var_node_id = cJSON_GetObjectItem(properties, "fun_obj_var_node_id")->valueint; - FunObjVar* funObjVar = id2funObjVarsMap[fun_obj_var_node_id]; - if (nullptr != funObjVar) - { - var->setFunction(funObjVar); - } - else - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << fun_obj_var_node_id <<" when updating FunValVar:"<(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GepValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - updateGepValVarAttributes(properties, var, pag); - - } - else if (nodeType == "ValVar") - { - ValVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ValVar found for id: " << id << "\n"; - continue; - } - updateSVFValVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstNullPtrObjVar") - { - ConstNullPtrObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstNullPtrObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstIntObjVar") - { - ConstIntObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstIntObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstFPObjVar") - { - ConstFPObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstFPObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstDataObjVar") - { - ConstDataObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstDataObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "DummyObjVar") - { - DummyObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching DummyObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "ConstAggObjVar") - { - ConstAggObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching ConstAggObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "GlobalObjVar") - { - GlobalObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching GlobalObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "FunObjVar") - { - FunObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching FunObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - updateFunObjVarAttributes(properties, var, pag); - } - else if (nodeType == "StackObjVar") - { - StackObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching StackObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "HeapObjVar") - { - HeapObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching HeapObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - else if (nodeType == "BaseObjVar") - { - BaseObjVar* var = SVFUtil::dyn_cast(pag->getGNode(id)); - if (var == nullptr) - { - SVFUtil::outs() << "Warning: [updateSVFPAGNodesAttributesFromDB] No matching BaseObjVar found for id: " << id << "\n"; - continue; - } - updateSVFBaseObjVarAtrributes(properties, var, pag); - } - skip += 1; - } - cJSON_Delete(root); - } - - } -} - - -void GraphDBClient::readPAGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, SVFIR* pag) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string result; - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* node; - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - SVFVar* var = nullptr; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; - const SVFType* type = pag->getSVFType(svfTypeId); - if (type == nullptr) - { - SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching SVFType found for type: " << svfTypeId << "for PAGNode:"<addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstIntValVar") - { - u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); - s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - var = new ConstIntValVar(id, sval, zval, type, ValVar::ConstIntValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstFPValVar") - { - double dval = cJSON_GetObjectItem(properties, "dval")->valuedouble; - var = new ConstFPValVar(id, dval, type, ValVar::ConstFPValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ArgValVar") - { - u32_t arg_no = static_cast(cJSON_GetObjectItem(properties, "arg_no")->valueint); - var = new ArgValVar(id, type,arg_no, ValVar::ArgValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "BlackHoleValVar") - { - var = new BlackHoleValVar(id, type, ValVar::BlackHoleValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstDataValVar") - { - var = new ConstDataValVar(id, type, ValVar::ConstDataValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "RetValPN") - { - var = new RetValPN(id, type, ValVar::RetValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "VarArgValPN") - { - var = new VarArgValPN(id, type, ValVar::VarargValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "DummyValVar") - { - var = new DummyValVar(id, type, ValVar::DummyValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstAggValVar") - { - var = new ConstAggValVar(id, type, ValVar::ConstAggValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "GlobalValVar") - { - var = new GlobalValVar(id, type, ValVar::GlobalValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "FunValVar") - { - var = new FunValVar(id, type, ValVar::FunValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "GepValVar") - { - int gep_val_svf_type_id = cJSON_GetObjectItem(properties, "gep_val_svf_type_id")->valueint; - const SVFType* gepValType = pag->getSVFType(gep_val_svf_type_id); - var = new GepValVar(id, type, gepValType, ValVar::GepValNode); - pag->addInitValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ValVar") - { - var = new ValVar(id, type, ValVar::ValNode); - pag->addValNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfValues(); - } - else if (nodeType == "ConstNullPtrObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new ConstNullPtrObjVar(id, type, objTypeInfo, ObjVar::ConstNullptrObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstIntObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - u64_t zval = std::stoull(cJSON_GetObjectItem(properties, "zval")->valuestring); - s64_t sval = cJSON_GetObjectItem(properties, "sval")->valueint; - var = new ConstIntObjVar(id, sval, zval, type, objTypeInfo, ObjVar::ConstIntObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstFPObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - float dval = (float)(cJSON_GetObjectItem(properties, "dval")->valuedouble); - var = new ConstFPObjVar(id, dval, type, objTypeInfo, ObjVar::ConstFPObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstDataObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new ConstDataObjVar(id, type, objTypeInfo, ObjVar::ConstDataObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "DummyObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new DummyObjVar(id, type, objTypeInfo, ObjVar::DummyObjNode); - pag->addDummyObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ConstAggObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new ConstAggObjVar(id, type, objTypeInfo, ObjVar::ConstAggObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "GlobalObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new GlobalObjVar(id, type, objTypeInfo, ObjVar::GlobalObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "FunObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - bool is_decl = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_decl")); - bool intrinsic = cJSON_IsTrue(cJSON_GetObjectItem(properties, "intrinsic")); - bool is_addr_taken = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_addr_taken")); - bool is_uncalled = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_uncalled")); - bool is_not_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_not_ret")); - bool sup_var_arg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "sup_var_arg")); - int fun_type_id = cJSON_GetObjectItem(properties, "fun_type_id")->valueint; - const SVFFunctionType* funcType = SVFUtil::dyn_cast(pag->getSVFType(fun_type_id)); - var = new FunObjVar(id, type, objTypeInfo, is_decl, intrinsic, is_addr_taken, is_uncalled, is_not_return, sup_var_arg, funcType, ObjVar::FunObjNode); - FunObjVar* funObjVar = SVFUtil::cast(var); - std::string func_annotation = cJSON_GetObjectItem(properties, "func_annotation")->valuestring; - if (!func_annotation.empty()) - { - std::vector func_annotation_vector; - func_annotation_vector = deserializeAnnotations(func_annotation); - ExtAPI::getExtAPI()->setExtFuncAnnotations(funObjVar, func_annotation_vector); - } - std::string val_name = cJSON_GetObjectItem(properties, "val_name")->valuestring; - if (!val_name.empty()) - { - funObjVar->setName(val_name); - } - std::string all_args_node_ids = cJSON_GetObjectItem(properties, "all_args_node_ids")->valuestring; - if (!all_args_node_ids.empty()) - { - std::vector all_args_node_ids_vec = parseElements2Container>(all_args_node_ids); - for (int arg_id : all_args_node_ids_vec) - { - ArgValVar* arg = SVFUtil::dyn_cast(pag->getGNode(arg_id)); - if (arg != nullptr) - { - funObjVar->addArgument(arg); - } - else - { - SVFUtil::outs() << "Warning: [readPAGNodesFromDB] No matching ArgValVar found for id: " << arg_id << "\n"; - } - } - } - pag->addBaseObjNodeFromDB(funObjVar); - id2funObjVarsMap[id] = funObjVar; - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "StackObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new StackObjVar(id, type, objTypeInfo, ObjVar::StackObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "HeapObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new HeapObjVar(id, type, objTypeInfo, ObjVar::HeapObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "BaseObjVar") - { - ObjTypeInfo* objTypeInfo = parseObjTypeInfoFromDB(properties, pag); - var = new BaseObjVar(id, type, objTypeInfo, ObjVar::BaseObjNode); - pag->addBaseObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "GepObjVar") - { - s64_t app_offset = cJSON_GetObjectItem(properties, "app_offset")->valueint; - int base_obj_var_node_id = cJSON_GetObjectItem(properties, "base_obj_var_node_id")->valueint; - const BaseObjVar* baseObj = pag->getBaseObject(base_obj_var_node_id); - var = new GepObjVar(id, type, app_offset, baseObj, ObjVar::GepObjNode); - pag->addGepObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - else if (nodeType == "ObjVar") - { - var = new ObjVar(id, type, ObjVar::ObjNode); - pag->addObjNodeFromDB(SVFUtil::cast(var)); - NodeIDAllocator::get()->increaseNumOfObjAndNodes(); - } - - std::string sourceLocation = parseNodeSourceLocation(node); - if (var != nullptr && !sourceLocation.empty()) - { - var->setSourceLoc(sourceLocation); - } - skip += 1; - } - cJSON_Delete(root); - } - } -} - -ObjTypeInfo* GraphDBClient::parseObjTypeInfoFromDB(cJSON* properties, SVFIR* pag) -{ - int obj_type_info_type_id = cJSON_GetObjectItem(properties, "obj_type_info_type_id")->valueint; - const SVFType* objTypeInfoType = pag->getSVFType(obj_type_info_type_id); - int obj_type_info_flags = cJSON_GetObjectItem(properties, "obj_type_info_flags")->valueint; - int obj_type_info_max_offset_limit = cJSON_GetObjectItem(properties, "obj_type_info_max_offset_limit")->valueint; - int obj_type_info_elem_num = cJSON_GetObjectItem(properties, "obj_type_info_elem_num")->valueint; - int obj_type_info_byte_size = cJSON_GetObjectItem(properties, "obj_type_info_byte_size")->valueint; - ObjTypeInfo* objTypeInfo = new ObjTypeInfo(objTypeInfoType, obj_type_info_flags, obj_type_info_max_offset_limit, obj_type_info_elem_num, obj_type_info_byte_size); - if (nullptr != objTypeInfo) - return objTypeInfo; - return nullptr; -} - -cJSON* GraphDBClient::queryFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string queryStatement) -{ - // parse all SVFType - std::string result; - if (!connection->CallCypher(result, queryStatement, dbname)) - { - SVFUtil::outs() << queryStatement<< "\n"; - SVFUtil::outs() << "Failed to query from DB:" << result << "\n"; - return nullptr; - } - cJSON* root = cJSON_Parse(result.c_str()); - if (!root || !cJSON_IsArray(root)) - { - SVFUtil::outs() << "Invalid JSON format: "<getId(); - std::string queryStatement ="MATCH (node) where node.fun_obj_var_id = " + std::to_string(funObjId) +" RETURN node "; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON* node; - BasicBlockGraph* bbGraph = new BasicBlockGraph(); - funObjVar->setBasicBlockGraph(bbGraph); - cJSON_ArrayForEach(node, root) - { - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - continue; - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - continue; - std::string id = cJSON_GetObjectItem(properties, "id")->valuestring; - std::string bb_name = - cJSON_GetObjectItem(properties, "bb_name")->valuestring; - int bbId = parseBBId(id); - SVFBasicBlock* bb = new SVFBasicBlock(bbId, funObjVar); - bb->setName(bb_name); - bbGraph->addBasicBlock(bb); - basicBlocks.insert(bb); - std::string allICFGNodeIds = cJSON_GetObjectItem(properties, "all_icfg_nodes_ids")->valuestring; - if (!allICFGNodeIds.empty()) - bb2AllICFGNodeIdstrMap.insert(std::make_pair(bb, allICFGNodeIds)); - } - cJSON_Delete(root); - } - -} - -void GraphDBClient::updateBasicBlockNodes(ICFG* icfg) -{ - for (auto& item:bb2AllICFGNodeIdstrMap) - { - SVFBasicBlock* bb = item.first; - std::string allICFGNodeIds = item.second; - if (!allICFGNodeIds.empty()) - { - std::vector allICFGNodeIdsVec = parseElements2Container>(allICFGNodeIds); - for (int icfgId : allICFGNodeIdsVec) - { - ICFGNode* icfgNode = icfg->getICFGNode(icfgId); - if (icfgNode != nullptr) - { - bb->addICFGNode(icfgNode); - } - else - { - SVFUtil::outs() << "Warning: [updateBasicBlockNodes] No matching ICFGNode found for id: " << icfgId << "\n"; - } - } - } - } -} - -void GraphDBClient::readBasicBlockEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, FunObjVar* funObjVar) -{ - BasicBlockGraph* bbGraph = funObjVar->getBasicBlockGraph(); - if (nullptr != bbGraph) - { - for (auto& pair: *bbGraph) - { - SVFBasicBlock* bb = pair.second; - std::string queryStatement = "MATCH (node{id:'"+std::to_string(bb->getId())+":"+std::to_string(bb->getFunction()->getId())+"'}) RETURN node.pred_bb_ids, node.sscc_bb_ids "; - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr != root) - { - cJSON* item; - cJSON_ArrayForEach(item, root) - { - if (!item) - continue; - std::string pred_bb_ids = cJSON_GetObjectItem(item, "node.pred_bb_ids")->valuestring; - std::string sscc_bb_ids = cJSON_GetObjectItem(item, "node.sscc_bb_ids")->valuestring; - if (!pred_bb_ids.empty()) - { - std::vector predBBIds = parseElements2Container>(pred_bb_ids); - for (int predBBId : predBBIds) - { - - SVFBasicBlock* predBB = bbGraph->getGNode(predBBId); - if (nullptr != predBB) - { - bb->addPredBasicBlock(predBB); - } - - } - } - if (!sscc_bb_ids.empty()) - { - std::vector ssccBBIds = parseElements2Container>(sscc_bb_ids); - for (int ssccBBId : ssccBBIds) - { - SVFBasicBlock* ssccBB = bbGraph->getGNode(ssccBBId); - if (nullptr != ssccBB) - { - bb->addSuccBasicBlock(ssccBB); - } - - } - } - } - cJSON_Delete(root); - } - - } - } -} - -ICFG* GraphDBClient::buildICFGFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Build ICFG from DB....\n"; - DBOUT(DGENERAL, outs() << pasMsg("\t Building ICFG From DB ...\n")); - ICFG* icfg = new ICFG(); - // read & add all the ICFG nodes from DB - readICFGNodesFromDB(connection, dbname, "GlobalICFGNode", icfg, pag); - readICFGNodesFromDB(connection, dbname, "FunEntryICFGNode", icfg, pag); - readICFGNodesFromDB(connection, dbname, "FunExitICFGNode", icfg, pag); - readICFGNodesFromDB(connection, dbname, "IntraICFGNode", icfg, pag); - // need to parse the RetICFGNode first before parsing the CallICFGNode - readICFGNodesFromDB(connection, dbname, "RetICFGNode", icfg, pag); - readICFGNodesFromDB(connection, dbname, "CallICFGNode", icfg, pag); - - // read & add all the ICFG edges from DB - readICFGEdgesFromDB(connection, dbname, "IntraCFGEdge", icfg, pag); - readICFGEdgesFromDB(connection, dbname, "CallCFGEdge", icfg, pag); - readICFGEdgesFromDB(connection, dbname, "RetCFGEdge", icfg, pag); - - updateBasicBlockNodes(icfg); - - return icfg; -} - -void GraphDBClient::readICFGNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string nodeType, ICFG* icfg, SVFIR* pag) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string queryStatement = " MATCH (node:"+nodeType+") RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* node; - cJSON_ArrayForEach(node, root) - { - ICFGNode* icfgNode = nullptr; - if (nodeType == "GlobalICFGNode") - { - icfgNode = parseGlobalICFGNodeFromDBResult(node); - if (nullptr != icfgNode) - { - icfg->addGlobalICFGNode(SVFUtil::cast(icfgNode)); - } - } - else if (nodeType == "IntraICFGNode") - { - icfgNode = parseIntraICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) - { - icfg->addICFGNode(icfgNode); - } - } - else if (nodeType == "FunEntryICFGNode") - { - icfgNode = parseFunEntryICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) - { - icfg->addFunEntryICFGNode(SVFUtil::cast(icfgNode)); - } - } - else if (nodeType == "FunExitICFGNode") - { - icfgNode = parseFunExitICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) - { - icfg->addFunExitICFGNode(SVFUtil::cast(icfgNode)); - } - } - else if (nodeType == "RetICFGNode") - { - icfgNode = parseRetICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) - { - icfg->addICFGNode(icfgNode); - id2RetICFGNodeMap[icfgNode->getId()] = SVFUtil::cast(icfgNode); - } - } - else if (nodeType == "CallICFGNode") - { - icfgNode = parseCallICFGNodeFromDBResult(node, pag); - if (nullptr != icfgNode) - { - CallICFGNode* callNode = SVFUtil::cast(icfgNode); - icfg->addICFGNode(callNode); - if (callNode->isIndirectCall()) - { - pag->addIndirectCallsites(callNode, callNode->getIndFunPtr()->getId()); - // SVFUtil::outs() << "Added indirect call site for node: " << callNode->getId() << "\n"; - pag->addCallSite(callNode); - } - else - { - const FunObjVar* calledFunc = callNode->getCalledFunction(); - if (calledFunc != nullptr && calledFunc->isIntrinsic() == false ) - { - // SVFUtil::outs() << "Added direct call site for node: " << callNode->getId() << "\n"; - pag->addCallSite(callNode); - } - } - } - } - - std::string sourceLocation = parseNodeSourceLocation(node); - if (!sourceLocation.empty()) - { - icfgNode->setSourceLoc(sourceLocation); - } - - if (nullptr == icfgNode) - { - SVFUtil::outs()<< "Failed to create "<< nodeType<< " from db query result\n"; - } - skip += 1; - } - cJSON_Delete(root); - } - } -} - -void GraphDBClient::parseSVFStmtsForICFGNodeFromDBResult(SVFIR* pag) -{ - if (!icfgNode2StmtsStrMap.empty()) - { - for (auto& pair : icfgNode2StmtsStrMap) - { - ICFGNode* icfgNode = pair.first; - std::string svfStmtIds = pair.second; - if (!svfStmtIds.empty()) - { - std::list svfStmtIdsVec = parseElements2Container>(svfStmtIds); - for (int stmtId : svfStmtIdsVec) - { - SVFStmt* stmt = edgeId2SVFStmtMap[stmtId]; - if (stmt != nullptr) - { - pag->addToSVFStmtList(icfgNode,stmt); - icfgNode->addSVFStmt(stmt); - } - else - { - SVFUtil::outs() << "Warning: [parseSVFStmtsForICFGNodeFromDBResult] No matching SVFStmt found for id: " << stmtId << "\n"; - } - } - } - } - } -} - -ICFGNode* GraphDBClient::parseGlobalICFGNodeFromDBResult(const cJSON* node) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - GlobalICFGNode* icfgNode; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - - icfgNode = new GlobalICFGNode(id); - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - return icfgNode; -} - -ICFGNode* GraphDBClient::parseFunEntryICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - FunEntryICFGNode* icfgNode; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - } - - // parse FunEntryICFGNode bb - int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; - SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); - - icfgNode = new FunEntryICFGNode(id, funObjVar, bb); - std::string fpNodesStr = cJSON_GetObjectItem(properties, "fp_nodes")->valuestring; - std::vector fpNodesIdVec = parseElements2Container>(fpNodesStr); - for (auto fpNodeId: fpNodesIdVec) - { - SVFVar* fpNode = pag->getGNode(fpNodeId); - if (nullptr != fpNode) - { - pag->addFunArgsFromDB(SVFUtil::cast(icfgNode), funObjVar, fpNode); - } - else - { - SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching fpNode SVFVar found for id: " << fpNodeId << "\n"; - } - } - - // if (nullptr != bb) - // { - // bb->addICFGNode(icfgNode); - // } - // else - // { - // SVFUtil::outs() << "Warning: [parseFunEntryICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - // } - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - - return icfgNode; -} - -ICFGNode* GraphDBClient::parseFunExitICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - FunExitICFGNode* icfgNode; - int id = cJSON_GetObjectItem(properties,"id")->valueint; - - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - } - - // parse FunExitICFGNode bb - int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; - SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); - - icfgNode = new FunExitICFGNode(id, funObjVar, bb); - int formal_ret_node_id = cJSON_GetObjectItem(properties, "formal_ret_node_id")->valueint; - if (formal_ret_node_id != -1) - { - SVFVar* formalRet = pag->getGNode(formal_ret_node_id); - if (nullptr != formalRet) - { - pag->addFunRetFromDB(SVFUtil::cast(icfgNode), funObjVar, formalRet); - } - else - { - SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching formalRet SVFVar found for id: " << formal_ret_node_id << "\n"; - } - } - - // if (nullptr != bb) - // { - // bb->addICFGNode(icfgNode); - // } - // else - // { - // SVFUtil::outs() << "Warning: [parseFunExitICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - // } - - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - return icfgNode; -} - -ICFGNode* GraphDBClient::parseIntraICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - IntraICFGNode* icfgNode; - int id = cJSON_GetObjectItem(properties, "id")->valueint; - // parse intraICFGNode funObjVar - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - } - - // parse intraICFGNode bb - int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; - SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); - - // parse isRet - bool is_return = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_return")); - - - icfgNode = new IntraICFGNode(id, bb, funObjVar, is_return); - - // // add this ICFGNode to its BasicBlock - // if (nullptr != bb) - // { - // bb->addICFGNode(icfgNode); - // } - // else - // { - // SVFUtil::outs() << "Warning: [parseIntraICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - // } - - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - return icfgNode; -} - -ICFGNode* GraphDBClient::parseRetICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - RetICFGNode* icfgNode; - // parse retICFGNode id - int id = cJSON_GetObjectItem(properties, "id")->valueint; - - // parse retICFGNode funObjVar - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - } - - // parse retICFGNode bb - int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; - SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); - - // parse retICFGNode svfType - int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; - const SVFType* type = pag->getSVFType(svfTypeId); - if (nullptr == type) - { - SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeId << "\n"; - } - - // create RetICFGNode Instance - icfgNode = new RetICFGNode(id, type, bb, funObjVar); - - // parse & add actualRet for RetICFGNode - int actual_ret_node_id = cJSON_GetObjectItem(properties, "actual_ret_node_id")->valueint; - if (actual_ret_node_id != -1) - { - SVFVar* actualRet = pag->getGNode(actual_ret_node_id); - if (nullptr != actualRet) - { - pag->addCallSiteRets(SVFUtil::cast(icfgNode), actualRet); - } - else - { - SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching actualRet SVFVar found for id: " << actual_ret_node_id << "\n"; - } - } - - // // add this ICFGNode to its BasicBlock - // if (nullptr != bb) - // { - // bb->addICFGNode(icfgNode); - // } - // else - // { - // SVFUtil::outs() << "Warning: [parseRetICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - // } - - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - return icfgNode; -} - -ICFGNode* GraphDBClient::parseCallICFGNodeFromDBResult(const cJSON* node, SVFIR* pag) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - CallICFGNode* icfgNode; - - // parse CallICFGNode id - int id = cJSON_GetObjectItem(properties, "id")->valueint; - - // parse CallICFGNode funObjVar - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - } - - // parse CallICFGNode bb - int bb_id = cJSON_GetObjectItem(properties, "bb_id")->valueint; - SVFBasicBlock* bb = funObjVar->getBasicBlockGraph()->getGNode(bb_id); - - // parse CallICFGNode svfType - int svfTypeId = cJSON_GetObjectItem(properties, "svf_type_id")->valueint; - const SVFType* type = pag->getSVFType(svfTypeId); - if (nullptr == type) - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching SVFType found for: " << svfTypeId << "\n"; - } - - // parse CallICFGNode calledFunObjVar - int called_fun_obj_var_id = cJSON_GetObjectItem(properties, "called_fun_obj_var_id")->valueint; - FunObjVar* calledFunc = nullptr; - if (called_fun_obj_var_id != -1) - { - auto calledFuncIt = id2funObjVarsMap.find(called_fun_obj_var_id); - if (calledFuncIt != id2funObjVarsMap.end()) - { - calledFunc = calledFuncIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching calledFunObjVar found for id: " << called_fun_obj_var_id << "\n"; - } - } - - bool is_vararg = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_vararg")); - bool is_vir_call_inst = cJSON_IsTrue(cJSON_GetObjectItem(properties, "is_vir_call_inst")); - - // parse CallICFGNode retICFGNode - int ret_icfg_node_id = cJSON_GetObjectItem(properties, "ret_icfg_node_id")->valueint; - RetICFGNode* retICFGNode = nullptr; - if (ret_icfg_node_id != -1) - { - auto retICFGNodeIt = id2RetICFGNodeMap.find(ret_icfg_node_id); - if (retICFGNodeIt != id2RetICFGNodeMap.end()) - { - retICFGNode = retICFGNodeIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching RetICFGNode found for id: " << ret_icfg_node_id << "\n"; - } - } - - std::string fun_name_of_v_call = ""; - s32_t virtualFunIdx = 0; - SVFVar* vtabPtr = nullptr; - if (is_vir_call_inst) - { - int virtual_fun_idx = cJSON_GetObjectItem(properties, "virtual_fun_idx")->valueint; - virtualFunIdx = static_cast(virtual_fun_idx); - int vtab_ptr_node_id = cJSON_GetObjectItem(properties, "vtab_ptr_node_id")->valueint; - vtabPtr = pag->getGNode(vtab_ptr_node_id); - fun_name_of_v_call = cJSON_GetObjectItem(properties, "fun_name_of_v_call")->valuestring; - } - - // create CallICFGNode Instance - icfgNode = new CallICFGNode(id, bb, type, funObjVar, calledFunc, retICFGNode, - is_vararg, is_vir_call_inst, virtualFunIdx, vtabPtr, fun_name_of_v_call); - - int indFunPtrId = cJSON_GetObjectItem(properties, "ind_fun_ptr_var_id")->valueint; - if (indFunPtrId != -1) - { - SVFVar* indFunPtr = pag->getGNode(indFunPtrId); - if (nullptr != indFunPtr) - { - icfgNode->setIndFunPtr(indFunPtr); - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching Indirect Function Pointer Var found for id: " << indFunPtrId << "\n"; - } - } - - // parse CallICFGNode APNodes - std::string ap_nodes = cJSON_GetObjectItem(properties, "ap_nodes")->valuestring; - if (!ap_nodes.empty() && ap_nodes!= "[]") - { - std::vector apNodesIdVec = parseElements2Container>(ap_nodes); - if (apNodesIdVec.size() > 0) - { - for (auto apNodeId: apNodesIdVec) - { - SVFVar* apNode = pag->getGNode(apNodeId); - if (nullptr != apNode) - { - pag->addCallSiteArgs(SVFUtil::cast(icfgNode), SVFUtil::cast(apNode)); - } - else - { - SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching APNode ValVar found for id: " << apNodeId << "\n"; - } - } - } - } - - if (retICFGNode != nullptr) - { - retICFGNode->addCallBlockNodeFromDB(icfgNode); - } - - // // add this ICFGNode to its BasicBlock - // if (nullptr != bb) - // { - // bb->addICFGNode(icfgNode); - // } - // else - // { - // SVFUtil::outs() << "Warning: [parseCallICFGNodeFromDBResult] No matching BasicBlock found for id: " << bb_id << "\n"; - // } - - std::string svfStmtIds = cJSON_GetObjectItem(properties, "pag_edge_ids")->valuestring; - if (!svfStmtIds.empty()) - { - icfgNode2StmtsStrMap[icfgNode] = svfStmtIds; - } - return icfgNode; -} - -void GraphDBClient::readICFGEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, std::string edgeType, ICFG* icfg, SVFIR* pag) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string queryStatement = "MATCH ()-[edge:"+edgeType+"]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* edge; - cJSON_ArrayForEach(edge, root) - { - ICFGEdge* icfgEdge = nullptr; - if (edgeType == "IntraCFGEdge") - { - icfgEdge = parseIntraCFGEdgeFromDBResult(edge, pag, icfg); - } - else if (edgeType == "CallCFGEdge") - { - icfgEdge = parseCallCFGEdgeFromDBResult(edge, pag, icfg); - } - else if (edgeType == "RetCFGEdge") - { - icfgEdge = parseRetCFGEdgeFromDBResult(edge, pag, icfg); - } - if (nullptr != icfgEdge) - { - icfg->addICFGEdge(icfgEdge); - } - else - { - SVFUtil::outs()<< "Failed to create "<< edgeType << " from db query result\n"; - } - skip += 1; - } - cJSON_Delete(root); - } - } -} - -ICFGEdge* GraphDBClient::parseIntraCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) -{ - cJSON* data = cJSON_GetObjectItem(edge, "edge"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - IntraCFGEdge* icfgEdge; - - // parse srcICFGNode & dstICFGNode - int src_id = cJSON_GetObjectItem(data,"src")->valueint; - int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; - ICFGNode* src = icfg->getICFGNode(src_id); - ICFGNode* dst = icfg->getICFGNode(dst_id); - - if (src == nullptr) - { - SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; - return nullptr; - } - if (dst == nullptr) - { - SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; - return nullptr; - } - - // create IntraCFGEdge Instance - icfgEdge = new IntraCFGEdge(src, dst); - - // parse branchCondVal & conditionalVar - int condition_var_id = cJSON_GetObjectItem(properties, "condition_var_id")->valueint; - int branch_cond_val = cJSON_GetObjectItem(properties, "branch_cond_val")->valueint; - s64_t branchCondVal = 0; - SVFVar* conditionVar; - if (condition_var_id != -1 && branch_cond_val != -1) - { - branchCondVal = static_cast(branch_cond_val); - conditionVar = pag->getGNode(condition_var_id); - if (nullptr == conditionVar) - { - SVFUtil::outs() << "Warning: [parseIntraCFGEdgeFromDBResult] No matching conditionVar found for id: " << condition_var_id << "\n"; - } - icfgEdge->setConditionVar(conditionVar); - icfgEdge->setBranchCondVal(branchCondVal); - } - - return icfgEdge; -} - -ICFGEdge* GraphDBClient::parseCallCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) -{ - cJSON* data = cJSON_GetObjectItem(edge, "edge"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - CallCFGEdge* icfgEdge; - // parse srcICFGNode & dstICFGNode - int src_id = cJSON_GetObjectItem(data,"src")->valueint; - int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; - ICFGNode* src = icfg->getICFGNode(src_id); - ICFGNode* dst = icfg->getICFGNode(dst_id); - if (src == nullptr) - { - SVFUtil::outs() << "Warning: [parseCallCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; - return nullptr; - } - if (dst == nullptr) - { - SVFUtil::outs() << "Warning: [parseCallCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; - return nullptr; - } - - // create CallCFGEdge Instance - icfgEdge = new CallCFGEdge(src, dst); - std::string call_pe_ids = cJSON_GetObjectItem(properties, "call_pe_ids")->valuestring; - if (!call_pe_ids.empty()) - { - callCFGEdge2CallPEStrMap[icfgEdge] = call_pe_ids; - } - return icfgEdge; -} - -ICFGEdge* GraphDBClient::parseRetCFGEdgeFromDBResult(const cJSON* edge, SVFIR* pag, ICFG* icfg) -{ - cJSON* data = cJSON_GetObjectItem(edge, "edge"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - RetCFGEdge* icfgEdge; - // parse srcICFGNode & dstICFGNode - int src_id = cJSON_GetObjectItem(data,"src")->valueint; - int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; - ICFGNode* src = icfg->getICFGNode(src_id); - ICFGNode* dst = icfg->getICFGNode(dst_id); - if (src == nullptr) - { - SVFUtil::outs() << "Warning: [parseRetCFGEdgeFromDBResult] No matching src ICFGNode found for id: " << src_id << "\n"; - return nullptr; - } - if (dst == nullptr) - { - SVFUtil::outs() << "Warning: [parseRetCFGEdgeFromDBResult] No matching dst ICFGNode found for id: " << dst_id << "\n"; - return nullptr; - } - - // create RetCFGEdge Instance - icfgEdge = new RetCFGEdge(src, dst); - int ret_pe_id = cJSON_GetObjectItem(properties, "ret_pe_id")->valueint; - if (ret_pe_id != -1) - { - retCFGEdge2RetPEStrMap[icfgEdge] = ret_pe_id; - } - return icfgEdge; -} - -CallGraph* GraphDBClient::buildCallGraphFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag) -{ - SVFUtil::outs()<< "Build CallGraph from DB....\n"; - DBOUT(DGENERAL, outs() << pasMsg("\t Building CallGraph From DB ...\n")); - CallGraph* callGraph = new CallGraph(); - readCallGraphNodesFromDB(connection, dbname, callGraph); - readCallGraphEdgesFromDB(connection, dbname, pag, callGraph); - - return callGraph; -} - -void GraphDBClient::readCallGraphNodesFromDB(lgraph::RpcClient* connection, const std::string& dbname, CallGraph* callGraph) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string queryStatement = " MATCH (node:CallGraphNode) RETURN node SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* node; - cJSON_ArrayForEach(node, root) - { - CallGraphNode* cgNode = nullptr; - cgNode = parseCallGraphNodeFromDB(node); - if (nullptr != cgNode) - { - callGraph->addCallGraphNode(cgNode); - } - skip += 1; - } - cJSON_Delete(root); - } - } -} - -void GraphDBClient::readCallGraphEdgesFromDB(lgraph::RpcClient* connection, const std::string& dbname, SVFIR* pag, CallGraph* callGraph) -{ - int skip = 0; - int limit = 1000; - while (true) - { - std::string queryStatement = "MATCH ()-[edge]->() RETURN edge SKIP "+std::to_string(skip)+" LIMIT "+std::to_string(limit); - cJSON* root = queryFromDB(connection, dbname, queryStatement); - if (nullptr == root) - { - break; - } - else - { - cJSON* edge; - cJSON_ArrayForEach(edge, root) - { - CallGraphEdge* cgEdge = nullptr; - cgEdge = parseCallGraphEdgeFromDB(edge, pag, callGraph); - if (nullptr != cgEdge) - { - if (cgEdge->isDirectCallEdge()) - { - callGraph->addDirectCallGraphEdge(cgEdge); - } - if (cgEdge->isIndirectCallEdge()) - { - callGraph->addIndirectCallGraphEdge(cgEdge); - } - } - skip += 1; - } - cJSON_Delete(root); - } - } -} - -CallGraphNode* GraphDBClient::parseCallGraphNodeFromDB(const cJSON* node) -{ - cJSON* data = cJSON_GetObjectItem(node, "node"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - int id = cJSON_GetObjectItem(properties,"id")->valueint; - - // parse funObjVar - int fun_obj_var_id = cJSON_GetObjectItem(properties, "fun_obj_var_id")->valueint; - FunObjVar* funObjVar = nullptr; - auto funObjVarIt = id2funObjVarsMap.find(fun_obj_var_id); - if (funObjVarIt != id2funObjVarsMap.end()) - { - funObjVar = funObjVarIt->second; - } - else - { - SVFUtil::outs() << "Warning: [parseCallGraphNodeFromDB] No matching FunObjVar found for id: " << fun_obj_var_id << "\n"; - return nullptr; - } - CallGraphNode* cgNode; - - // create callGraph node instance - cgNode = new CallGraphNode(id, funObjVar); - - std::string sourceLocation = cJSON_GetObjectItem(properties, "source_loc")->valuestring; - if ( !sourceLocation.empty() ) - { - cgNode->setSourceLoc(sourceLocation); - } - - return cgNode; -} - -CallGraphEdge* GraphDBClient::parseCallGraphEdgeFromDB(const cJSON* edge, SVFIR* pag, CallGraph* callGraph) -{ - CallGraphEdge* cgEdge = nullptr; - cJSON* data = cJSON_GetObjectItem(edge, "edge"); - if (!data) - return nullptr; - - cJSON* properties = cJSON_GetObjectItem(data, "properties"); - if (!properties) - return nullptr; - - int src_id = cJSON_GetObjectItem(data,"src")->valueint; - int dst_id = cJSON_GetObjectItem(data,"dst")->valueint; - int csid = cJSON_GetObjectItem(properties,"csid")->valueint; - std::string direct_call_set = cJSON_GetObjectItem(properties,"direct_call_set")->valuestring; - std::string indirect_call_set = cJSON_GetObjectItem(properties, "indirect_call_set")->valuestring; - int kind = cJSON_GetObjectItem(properties, "kind")->valueint; - - CallGraphNode* srcNode = callGraph->getGNode(src_id); - CallGraphNode* dstNode = callGraph->getGNode(dst_id); - if (srcNode == nullptr) - { - SVFUtil::outs() << "Warning: [parseCallGraphEdgeFromDB] No matching src CallGraphNode found for id: " << src_id << "\n"; - return nullptr; - } - if (dstNode == nullptr) - { - SVFUtil::outs() << "Warning: [parseCallGraphEdgeFromDB] No matching dst CallGraphNode found for id: " << dst_id << "\n"; - return nullptr; - } - - // create CallGraphEdge Instance - cgEdge = new CallGraphEdge(srcNode, dstNode, static_cast(kind), csid); - Set direct_call_set_ids; - if (!direct_call_set.empty()) - { - direct_call_set_ids = parseElements2Container>(direct_call_set); - for (int directCallId : direct_call_set_ids) - { - CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(directCallId)); - callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); - cgEdge->addDirectCallSite(node); - callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); - } - } - - Set indirect_call_set_ids; - if (!indirect_call_set.empty()) - { - indirect_call_set_ids = parseElements2Container>(indirect_call_set); - for (int indirectCallId : indirect_call_set_ids) - { - CallICFGNode* node = SVFUtil::dyn_cast(pag->getICFG()->getGNode(indirectCallId)); - callGraph->numOfResolvedIndCallEdge++; - callGraph->addCallSite(node, node->getFun(), cgEdge->getCallSiteID()); - cgEdge->addInDirectCallSite(node); - callGraph->callinstToCallGraphEdgesMap[node].insert(cgEdge); - } - } - - return cgEdge; -} - -/// BasicBlockGraph insertions query statements -const std::string GraphDBClient::bbEdge2DBString(const BasicBlockEdge* edge) -{ - const std::string queryStatement = - "MATCH (n:SVFBasicBlock {id:'"+std::to_string(edge->getSrcID())+":"+std::to_string(edge->getSrcNode()->getFunction()->getId())+ - "'}), (m:SVFBasicBlock{id:'"+std::to_string(edge->getDstID())+":"+std::to_string(edge->getDstNode()->getFunction()->getId())+ - "'}) WHERE n.id = '" +std::to_string(edge->getSrcID())+":" + std::to_string(edge->getSrcNode()->getFunction()->getId())+ "'"+ - " AND m.id = '" +std::to_string(edge->getDstID())+":" + std::to_string(edge->getDstNode()->getFunction()->getId())+ "'"+ - " CREATE (n)-[r:BasicBlockEdge{}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::bb2DBString(const SVFBasicBlock* bb) -{ - const std::string queryStatement ="CREATE (n:SVFBasicBlock {id:'" + std::to_string(bb->getId())+":" + std::to_string(bb->getFunction()->getId()) + "'" + - ", fun_obj_var_id: " + std::to_string(bb->getFunction()->getId()) + - ", bb_name:'" + bb->getName() +"'" + - ", sscc_bb_ids:'" + extractNodesIds(bb->getSuccBBs()) + "'" + - ", pred_bb_ids:'" + extractNodesIds(bb->getPredBBs()) + "'" + - ", all_icfg_nodes_ids:'" + extractNodesIds(bb->getICFGNodeList()) + "'" + - + "})"; - return queryStatement; -} - -/// CallGraph insertions query statements -const std::string GraphDBClient::callGraphNode2DBString(const CallGraphNode* node) -{ - const std::string queryStatement ="CREATE (n:CallGraphNode {id: " + std::to_string(node->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFunction()->getId()) + - node->sourceLocToDBString() + - ", fun_name:'" + node->getName()+ "'" - "})"; - return queryStatement; -} - -const std::string GraphDBClient::callGraphEdge2DBString(const CallGraphEdge* edge) -{ - std::string indirectCallIds = ""; - Set indirectCall = edge->getIndirectCalls(); - if (indirectCall.size() > 0) - { - indirectCallIds = extractNodesIds(indirectCall); - } - - std::string directCallIds = ""; - Set directCall = edge->getDirectCalls(); - if (directCall.size() > 0) - { - directCallIds = extractNodesIds(directCall); - } - - const std::string queryStatement = - "MATCH (n:CallGraphNode{id:"+std::to_string(edge->getSrcNode()->getId())+"}), (m:CallGraphNode{id:"+std::to_string(edge->getDstNode()->getId()) + "}) WHERE n.id = " + - std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:CallGraphEdge{csid:" + std::to_string(edge->getCallSiteID()) + - ", kind:" + std::to_string(edge->getEdgeKind()) + - ", direct_call_set:'" + directCallIds + "', indirect_call_set:'" + - indirectCallIds + "'}]->(m)"; - return queryStatement; -} - -/// ICFG insertions query statements -const std::string GraphDBClient::intraCFGEdge2DBString(const IntraCFGEdge* edge) -{ - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - std::string condition = ""; - if (edge->getCondition() != nullptr) - { - condition = - ", condition_var_id:" + std::to_string(edge->getCondition()->getId()) + - ", branch_cond_val:" + std::to_string(edge->getSuccessorCondValue()); - } - else - { - condition = ", condition_var_id:-1, branch_cond_val:-1"; - } - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:IntraCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - condition + "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::callCFGEdge2DBString(const CallCFGEdge* edge) -{ - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:CallCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - ", call_pe_ids:'" + extractEdgesIds(edge->getCallPEs()) + "'}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::retCFGEdge2DBString(const RetCFGEdge* edge) -{ - std::string srcKind = getICFGNodeKindString(edge->getSrcNode()); - std::string dstKind = getICFGNodeKindString(edge->getDstNode()); - std::string ret_pe_id = ""; - if (edge->getRetPE() != nullptr) - { - ret_pe_id = ", ret_pe_id:" + std::to_string(edge->getRetPE()->getEdgeID()); - } - else - { - ret_pe_id = ", ret_pe_id:-1"; - } - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(edge->getSrcNode()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(edge->getDstNode()->getId()) + - "}) WHERE n.id = " + std::to_string(edge->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(edge->getDstNode()->getId()) + - " CREATE (n)-[r:RetCFGEdge{kind:" + std::to_string(edge->getEdgeKind()) + - ret_pe_id + "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::globalICFGNode2DBString(const GlobalICFGNode* node) -{ - const std::string queryStatement ="CREATE (n:GlobalICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'"+ - node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::intraICFGNode2DBString(const IntraICFGNode* node) -{ - const std::string queryStatement ="CREATE (n:IntraICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", is_return: " + (node->isRetInst() ? "true" : "false") + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(node->getBB()->getId()) + - node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::interICFGNode2DBString(const InterICFGNode* node) -{ - const std::string queryStatement ="CREATE (n:InterICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'"+ - node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::funEntryICFGNode2DBString(const FunEntryICFGNode* node) -{ - const std::string queryStatement ="CREATE (n:FunEntryICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(node->getBB()->getId()) + - ", fp_nodes:'" + extractNodesIds(node->getFormalParms()) +"'"+ - node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::funExitICFGNode2DBString(const FunExitICFGNode* node) -{ - std::string formalRetId = ""; - if (nullptr == node->getFormalRet()) - { - formalRetId = ",formal_ret_node_id:-1"; - } else { - formalRetId = ",formal_ret_node_id:" + std::to_string(node->getFormalRet()->getId()); - } - const std::string queryStatement ="CREATE (n:FunExitICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ", fun_obj_var_id:" + std::to_string(node->getFun()->getId()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + - ", bb_id:" + std::to_string(node->getBB()->getId()) + - formalRetId + node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::retICFGNode2DBString(const RetICFGNode* node) -{ - std::string actual_ret_node_id=""; - if (node->getActualRet() != nullptr) - { - actual_ret_node_id = ", actual_ret_node_id: " + std::to_string(node->getActualRet()->getId()) ; - } else { - actual_ret_node_id = ", actual_ret_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:RetICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - actual_ret_node_id+ - ", call_block_node_id: " + std::to_string(node->getCallICFGNode()->getId()) + - ", bb_id: " + std::to_string(node->getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + - ", svf_type_id:" + std::to_string(node->getType()->getId()) + node->sourceLocToDBString() + "})"; - return queryStatement; -} - -const std::string GraphDBClient::callICFGNode2DBString(const CallICFGNode* node) -{ - std::string fun_name_of_v_call = ""; - std::string vtab_ptr_node_id = ""; - std::string virtual_fun_idx = ""; - std::string is_vir_call_inst = node->isVirtualCall() ? "true" : "false"; - std::string virtualFunAppendix = ""; - int indFunPtrId = -1; - if (node->isIndirectCall()) - { - indFunPtrId = node->getIndFunPtr()->getId(); - } - if (node->isVirtualCall()) - { - fun_name_of_v_call = ", fun_name_of_v_call: '"+node->getFunNameOfVirtualCall()+"'"; - vtab_ptr_node_id = ", vtab_ptr_node_id:" + std::to_string(node->getVtablePtr()->getId()); - virtual_fun_idx = ", virtual_fun_idx:" + std::to_string(node->getFunIdxInVtable()); - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx+fun_name_of_v_call; - } - else - { - vtab_ptr_node_id = ", vtab_ptr_node_id:-1"; - virtual_fun_idx = ", virtual_fun_idx:-1"; - virtualFunAppendix = vtab_ptr_node_id+virtual_fun_idx; - } - std::string called_fun_obj_var_id = ""; - if (node->getCalledFunction() != nullptr) - { - called_fun_obj_var_id = ", called_fun_obj_var_id:" + std::to_string(node->getCalledFunction()->getId()); - } - else - { - called_fun_obj_var_id = ", called_fun_obj_var_id: -1"; - } - std::string ret_icfg_node_id = ""; - if (node->getRetICFGNode() != nullptr) - { - ret_icfg_node_id = ", ret_icfg_node_id: " + std::to_string(node->getRetICFGNode()->getId()); - } - else - { - ret_icfg_node_id = ", ret_icfg_node_id: -1"; - } - const std::string queryStatement ="CREATE (n:CallICFGNode {id: " + std::to_string(node->getId()) + - ", kind: " + std::to_string(node->getNodeKind()) + - ret_icfg_node_id + - ", bb_id: " + std::to_string(node->getBB()->getId()) + - ", fun_obj_var_id: " + std::to_string(node->getFun()->getId()) + - ", pag_edge_ids:'" + extractEdgesIds(node->getSVFStmts()) +"'" + - ", svf_type_id:" + std::to_string(node->getType()->getId()) + - ", ap_nodes:'" + extractNodesIds(node->getActualParms()) +"'" + - called_fun_obj_var_id + - ", is_vararg: " + (node->isVarArg() ? "true" : "false") + - ", is_vir_call_inst: " + (node->isVirtualCall() ? "true" : "false") + - ", ind_fun_ptr_var_id:" + std::to_string(indFunPtrId) + - virtualFunAppendix+ node->sourceLocToDBString() +"})"; - return queryStatement; -} - -/// SVFType insertions query statements -const std::string GraphDBClient::stInfo2DBString(const StInfo* stinfo) -{ - const std::string queryStatement ="CREATE (n:StInfo {st_info_id:" + std::to_string(stinfo->getStinfoId()) + - ", fld_idx_vec:'" + extractIdxs(stinfo->getFlattenedFieldIdxVec()) + - "', elem_idx_vec:'" + extractIdxs(stinfo->getFlattenedElemIdxVec()) + - "', finfo_types:'" + extractSVFTypes(stinfo->getFlattenFieldTypes()) + - "', flatten_element_types:'" + extractSVFTypes(stinfo->getFlattenElementTypes()) + - "', fld_idx_2_type_map:'" + extractFldIdx2TypeMap(stinfo->getFldIdx2TypeMap()) + - "', stride:" + std::to_string(stinfo->getStride()) + - ", num_of_flatten_elements:" + std::to_string(stinfo->getNumOfFlattenElements()) + - ", num_of_flatten_fields:" + std::to_string(stinfo->getNumOfFlattenFields()) + "})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFPointerType2DBString(const SVFPointerType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFPointerType {id:" + std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + "})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFArrayType2DBString(const SVFArrayType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFArrayType {id:" +std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", stinfo_node_id:" + std::to_string(type->getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + - ", num_of_element:" + std::to_string(type->getNumOfElement()) + - ", type_of_element_node_type_id:" + std::to_string(type->getTypeOfElement()->getId()) + "})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFIntegerType2DBString(const SVFIntegerType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFIntegerType {id:" + std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + - ", single_and_width:" + std::to_string(type->getSignAndWidth()) + "})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFFunctionType2DBString(const SVFFunctionType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFFunctionType {id:" + std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + - ", params_types_vec:'" + extractSVFTypes(type->getParamTypes()) + - "', ret_ty_node_id:" + std::to_string(type->getReturnType()->getId()) + "})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFStructType2DBString(const SVFStructType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFStructType {id:" + std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", stinfo_node_id:" + std::to_string(type->getTypeInfo()->getStinfoId()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + - ", struct_name:'" + type->getName() + "'" + - ", fields_id_vec:'" + extractSVFTypes(type->getFieldTypes()) + - "'})"; - return queryStatement; -} - -const std::string GraphDBClient::SVFOtherType2DBString(const SVFOtherType* type) -{ - std::string is_single_val_ty = type->isSingleValueType() ? "true" : "false"; - const std::string queryStatement ="CREATE (n:SVFOtherType {id:" + std::to_string(type->getId()) + - ", svf_i8_type_id:" + std::to_string(type->getSVFInt8Type()->getId()) + - ", svf_ptr_type_id:" + std::to_string(type->getSVFPtrType()->getId()) + - ", kind:" + std::to_string(type->getKind()) + - ", is_single_val_ty:" + is_single_val_ty + - ", byte_size:" + std::to_string(type->getByteSize()) + - ", repr:'" + type->getRepr() + "'})"; - return queryStatement; -} - -/// PAG insertions query statements -const std::string GraphDBClient::generateSVFStmtEdgeFieldsStmt(const SVFStmt* stmt) -{ - std::string valueStr = ""; - if (nullptr != stmt->getValue()) - { - valueStr += ", svf_var_node_id:"+ std::to_string(stmt->getValue()->getId()); - } - else - { - valueStr += ", svf_var_node_id:-1"; - } - std::string bb_id_str = ""; - if (nullptr != stmt->getBB()) - { - bb_id_str += ", bb_id:'" + std::to_string(stmt->getBB()->getParent()->getId()) + ":" + std::to_string(stmt->getBB()->getId())+"'"; - } - else - { - bb_id_str += ", bb_id:''"; - } - - std::string icfg_node_id_str = ""; - if (nullptr != stmt->getICFGNode()) - { - icfg_node_id_str += ", icfg_node_id:" + std::to_string(stmt->getICFGNode()->getId()); - } - else - { - icfg_node_id_str += ", icfg_node_id:-1"; - } - - std::string inst2_label_map = ""; - if (nullptr != stmt->getInst2LabelMap() && !stmt->getInst2LabelMap()->empty()) - { - inst2_label_map += ", inst2_label_map:'"+ extractLabelMap2String(stmt->getInst2LabelMap()) +"'"; - } - - std::string var2_label_map = ""; - if (nullptr != stmt->getVar2LabelMap() && !stmt->getVar2LabelMap()->empty()) - { - var2_label_map += ", var2_label_map:'"+ extractLabelMap2String(stmt->getVar2LabelMap()) +"'"; - } - std::string fieldsStr = ""; - fieldsStr += "edge_id: " + std::to_string(stmt->getEdgeID()) + - valueStr + - bb_id_str + - icfg_node_id_str + - inst2_label_map + - var2_label_map + - ", call_edge_label_counter:" + std::to_string(*(stmt->getCallEdgeLabelCounter())) + - ", store_edge_label_counter:" + std::to_string(*(stmt->getStoreEdgeLabelCounter())) + - ", multi_opnd_label_counter:" + std::to_string(*(stmt->getMultiOpndLabelCounter())) + - ", edge_flag:" + std::to_string(stmt->getEdgeKindWithoutMask()); - return fieldsStr; -} - -const std::string GraphDBClient::SVFStmt2DBString(const SVFStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getSrcNode()); - std::string dstKind = getPAGNodeKindString(stmt->getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->getDstNode()->getId()) + - " CREATE (n)-[r:SVFStmt{"+ - generateSVFStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::AssignStmt2DBString(const AssignStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - const std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:" + srcKind + "{id:" + std::to_string(stmt->getRHSVar()->getId()) + - "}), (m:" + dstKind + "{id:" + std::to_string(stmt->getLHSVar()->getId()) + - "}) WHERE n.id = " + std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:AssignStmt{" + generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::AddrStmt2DBString(const AddrStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:AddrStmt{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", arr_size:'" + extractNodesIds(stmt->getArrSize()) +"'"+ - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::CopyStmt2DBString(const CopyStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:CopyStmt{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", copy_kind:" + std::to_string(stmt->getCopyKind()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::StoreStmt2DBString(const StoreStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:StoreStmt{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::LoadStmt2DBString(const LoadStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:LoadStmt{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::GepStmt2DBString(const GepStmt* stmt) -{ - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - std::ostringstream accessPathStr; - accessPathStr << ""; - if (!stmt->isVariantFieldGep()) - { - accessPathStr << ", ap_fld_idx:" - << std::to_string(stmt->getConstantStructFldIdx()); - } - else - { - accessPathStr << ", ap_fld_idx:-1"; - } - - if (nullptr != stmt->getAccessPath().gepSrcPointeeType()) - { - accessPathStr << ", ap_gep_pointee_type_id:"<< stmt->getAccessPath().gepSrcPointeeType()->getId(); - } - else - { - accessPathStr << ", ap_gep_pointee_type_id:-1"; - } - if (!stmt->getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathStr << ", ap_idx_operand_pairs:'" - << IdxOperandPairsToString(&(stmt->getAccessPath().getIdxOperandPairVec())) - << "'"; - } - - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:GepStmt{" + generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - accessPathStr.str() + - ", variant_field:" + (stmt->isVariantFieldGep()? "true" : "false") + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::CallPE2DBString(const CallPE* stmt) -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != stmt->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != stmt->getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(stmt->getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:CallPE{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::RetPE2DBString(const RetPE* stmt) -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != stmt->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != stmt->getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(stmt->getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:RetPE{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::MultiOpndStmt2DBString(const MultiOpndStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:MultiOpndStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::PhiStmt2DBString(const PhiStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:PhiStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", op_icfg_nodes_ids:'" + extractNodesIds(*(stmt->getOpICFGNodeVec())) + "'"+ - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::SelectStmt2DBString(const SelectStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:SelectStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", condition_svf_var_node_id:" + std::to_string(stmt->getCondition()->getId()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::CmpStmt2DBString(const CmpStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:CmpStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", predicate:" + std::to_string(stmt->getPredicate()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::BinaryOPStmt2DBString(const BinaryOPStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:BinaryOPStmt{"+ - generateMultiOpndStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", op_code:" + std::to_string(stmt->getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::UnaryOPStmt2DBString(const UnaryOPStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:UnaryOPStmt{"+ - generateSVFStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", op_code:" + std::to_string(stmt->getOpcode()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::BranchStmt2DBString(const BranchStmt* stmt) -{ - const std::string srcKind = getPAGNodeKindString(stmt->SVFStmt::getSrcNode()); - const std::string dstKind = getPAGNodeKindString(stmt->SVFStmt::getDstNode()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->SVFStmt::getSrcNode()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->SVFStmt::getDstNode()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->SVFStmt::getSrcNode()->getId()) + - " AND m.id = " + std::to_string(stmt->SVFStmt::getDstNode()->getId()) + - " CREATE (n)-[r:BranchStmt{"+ - generateSVFStmtEdgeFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - ", successors:'" + extractSuccessorsPairSet2String(&(stmt->getSuccessors())) + "'"+ - ", condition_svf_var_node_id:" + std::to_string(stmt->getCondition()->getId()) + - ", br_inst_svf_var_node_id:" + std::to_string(stmt->getBranchInst()->getId()) + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::TDForkPE2DBString(const TDForkPE* stmt) -{ - std::string callInstStr = ""; - std::string funEntryICFGNodeStr = ""; - if (nullptr != stmt->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != stmt->getFunEntryICFGNode()) - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:" + std::to_string(stmt->getFunEntryICFGNode()->getId()); - } - else - { - funEntryICFGNodeStr += ", fun_entry_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:TDForkPE{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - callInstStr + - funEntryICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::TDJoinPE2DBString(const TDJoinPE* stmt) -{ - std::string callInstStr = ""; - std::string funExitICFGNodeStr = ""; - if (nullptr != stmt->getCallInst()) - { - callInstStr += ", call_icfg_node_id:" + std::to_string(stmt->getCallInst()->getId()); - } - else - { - callInstStr += ", call_icfg_node_id:-1"; - } - - if (nullptr != stmt->getFunExitICFGNode()) - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:" + std::to_string(stmt->getFunExitICFGNode()->getId()); - } - else - { - funExitICFGNodeStr += ", fun_exit_icfg_node_id:-1"; - } - std::string srcKind = getPAGNodeKindString(stmt->getRHSVar()); - std::string dstKind = getPAGNodeKindString(stmt->getLHSVar()); - const std::string queryStatement = - "MATCH (n:"+srcKind+"{id:"+std::to_string(stmt->getRHSVar()->getId())+"}), (m:"+ - dstKind+"{id:"+std::to_string(stmt->getLHSVar()->getId())+"}) WHERE n.id = " + - std::to_string(stmt->getRHSVar()->getId()) + - " AND m.id = " + std::to_string(stmt->getLHSVar()->getId()) + - " CREATE (n)-[r:TDJoinPE{"+ - generateAssignStmtFieldsStmt(stmt) + - ", kind:" + std::to_string(stmt->getEdgeKind()) + - callInstStr + - funExitICFGNodeStr + - "}]->(m)"; - return queryStatement; -} - -const std::string GraphDBClient::valVar2DBString(const ValVar* var) -{ - const std::string queryStatement ="CREATE (n:ValVar {"+ - getValVarNodeFieldsStmt(var)+ - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::objVar2DBString(const ObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ObjVar {"+ - getObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::argValVar2DBString(const ArgValVar* var) -{ - const std::string queryStatement ="CREATE (n:ArgValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", cg_node_id:" + std::to_string(var->getParent()->getId()) - + ", arg_no:" + std::to_string(var->getArgNo()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::gepValVar2DBString(const GepValVar* var) -{ - std::ostringstream accessPathFieldsStr; - accessPathFieldsStr << ""; - - if (nullptr != var->getAccessPath().gepSrcPointeeType()) - { - accessPathFieldsStr << ", ap_gep_pointee_type_id:"<getAccessPath().gepSrcPointeeType()->getId(); - } - else - { - accessPathFieldsStr << ", ap_gep_pointee_type_id:-1"; - } - if (!var->getAccessPath().getIdxOperandPairVec().empty()) - { - accessPathFieldsStr <<", ap_idx_operand_pairs:'"<< IdxOperandPairsToString(&(var->getAccessPath().getIdxOperandPairVec()))<<"'"; - } - const std::string queryStatement ="CREATE (n:GepValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", base_val_id:" + std::to_string(var->getBaseNode()->getId()) - + ", gep_val_svf_type_id:"+std::to_string(var->getType()->getId()) - + ", ap_fld_idx:"+std::to_string(var->getConstantFieldIdx()) - + ", llvm_var_inst_id:" + std::to_string(var->getLLVMVarInstID()) - + accessPathFieldsStr.str() - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::baseObjVar2DBString(const BaseObjVar* var) -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::gepObjVar2DBString(const GepObjVar* var) -{ - const std::string queryStatement ="CREATE (n:BaseObjVar {"+ - getObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", base_obj_var_node_id:" + std::to_string(var->getBaseObj()->getId()) - + ", app_offset:" + std::to_string(var->getConstantFieldIdx()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::heapObjVar2DBString(const HeapObjVar* var) -{ - const std::string queryStatement ="CREATE (n:HeapObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::stackObjVar2DBString(const StackObjVar* var) -{ - const std::string queryStatement ="CREATE (n:StackObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::funObjVar2DBString(const FunObjVar* var) -{ - std::ostringstream exitBBStr; - if (var->hasBasicBlock() && nullptr != var->getExitBB()) - { - exitBBStr << ", exit_bb_id:" << std::to_string(var->getExitBB()->getId()); - } - else - { - exitBBStr << ", exit_bb_id:-1"; - } - std::string annotationsStr = ""; - std::vector annotationsVector; - annotationsVector = ExtAPI::getExtAPI()->getExtFuncAnnotations(var); - if (annotationsVector.size() > 0) - { - annotationsStr = serializeAnnotations(annotationsVector); - } - std::ostringstream valNameStr; - if (var->getName().empty()) - { - valNameStr << ",val_name:''"; - } - else - { - valNameStr << ",val_name:'"<getName()<<"'"; - } - const std::string queryStatement ="CREATE (n:FunObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", is_decl:" + (var->isDeclaration()? "true" : "false") - + ", intrinsic:" + (var->isIntrinsic()? "true" : "false") - + ", is_addr_taken:" + (var->hasAddressTaken()? "true" : "false") - + ", is_uncalled:" + (var->isUncalledFunction()? "true" : "false") - + ", is_not_ret:" + (var->getIsNotRet()? "true" : "false") - + ", sup_var_arg:" + (var->isVarArg()? "true" : "false") - + ", fun_type_id:" + std::to_string(var->getFunctionType()->getId()) - + ", real_def_fun_node_id:" + std::to_string(var->getDefFunForMultipleModule()->getId()) - // + ", bb_graph_id:" + std::to_string(node->getBasicBlockGraph()->getFunObjVarId()) - + exitBBStr.str() - + ", all_args_node_ids:'" + extractNodesIds(var->getArgs()) + "'" - + ", reachable_bbs:'" + extractNodesIds(var->getReachableBBs()) + "'" - + ", dt_bbs_map:'" + extractBBsMapWithSet2String(&(var->getDomTreeMap())) + "'" - + ", pdt_bbs_map:'" + extractBBsMapWithSet2String(&(var->getLoopAndDomInfo()->getPostDomTreeMap())) + "'" - + ", df_bbs_map:'" + extractBBsMapWithSet2String(&(var->getDomFrontierMap())) + "'" - + ", bb2_loop_map:'" + extractBBsMapWithSet2String(&(var->getLoopAndDomInfo()->getBB2LoopMap())) + "'" - + ", bb2_p_dom_level:'" + extractLabelMap2String(&(var->getLoopAndDomInfo()->getBBPDomLevel())) + "'" - + ", bb2_pi_dom:'" + extractBBsMap2String(&(var->getLoopAndDomInfo()->getBB2PIdom())) + "'" - + ", func_annotation:'" + annotationsStr + "'" - + valNameStr.str() - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::funValVar2DBString(const FunValVar* var) -{ - const std::string queryStatement ="CREATE (n:FunValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", fun_obj_var_node_id:" + std::to_string(var->getFunction()->getId()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::globalValVar2DBString(const GlobalValVar* var) -{ - const std::string queryStatement ="CREATE (n:GlobalValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constAggValVar2DBString(const ConstAggValVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstAggValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constDataValVar2DBString(const ConstDataValVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstDataValVar {"+ - getConstDataValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::blackHoleValVar2DBString(const BlackHoleValVar* var) -{ - const std::string queryStatement ="CREATE (n:BlackHoleValVar {"+ - getConstDataValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constFPValVar2DBString(const ConstFPValVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstFPValVar {"+ - getConstDataValVarNodeFieldsStmt(var) - +", kind:" + std::to_string(var->getNodeKind()) - +", dval:"+ std::to_string(var->getFPValue()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constIntValVar2DBString(const ConstIntValVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstIntValVar {"+ - getConstDataValVarNodeFieldsStmt(var) - +", kind:" + std::to_string(var->getNodeKind()) - +", zval:'"+ std::to_string(var->getZExtValue()) + "'" - +", sval:"+ std::to_string(var->getSExtValue()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constNullPtrValVar2DBString(const ConstNullPtrValVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrValVar {"+ - getConstDataValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::globalObjVar2DBString(const GlobalObjVar* var) -{ - const std::string queryStatement ="CREATE (n:GlobalObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constAggObjVar2DBString(const ConstAggObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstAggObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constDataObjVar2DBString(const ConstDataObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstDataObjVar {"+ - getConstDataObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constFPObjVar2DBString(const ConstFPObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstFPObjVar {"+ - getConstDataObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", dval:" + std::to_string(var->getFPValue()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constIntObjVar2DBString(const ConstIntObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstIntObjVar {"+ - getConstDataObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + ", zval:'" + std::to_string(var->getZExtValue()) + "'" - + ", sval:" + std::to_string(var->getSExtValue()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::constNullPtrObjVar2DBString(const ConstNullPtrObjVar* var) -{ - const std::string queryStatement ="CREATE (n:ConstNullPtrObjVar {"+ - getConstDataObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::retValPN2DBString(const RetValPN* var) -{ - const std::string queryStatement ="CREATE (n:RetValPN {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - +", call_graph_node_id:"+std::to_string(var->getCallGraphNode()->getId()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::varArgValPN2DBString(const VarArgValPN* var) -{ - const std::string queryStatement ="CREATE (n:VarArgValPN {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - +", call_graph_node_id:"+std::to_string(var->getFunction()->getId()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::dummyValVar2DBString(const DummyValVar* var) -{ - const std::string queryStatement ="CREATE (n:DummyValVar {"+ - getValVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - -const std::string GraphDBClient::dummyObjVar2DBString(const DummyObjVar* var) -{ - const std::string queryStatement ="CREATE (n:DummyObjVar {"+ - getBaseObjVarNodeFieldsStmt(var) - + ", kind:" + std::to_string(var->getNodeKind()) - + "})"; - return queryStatement; -} - diff --git a/svf/lib/SVFIR/SVFIR.cpp b/svf/lib/SVFIR/SVFIR.cpp index 67d3a483b..702af01e1 100644 --- a/svf/lib/SVFIR/SVFIR.cpp +++ b/svf/lib/SVFIR/SVFIR.cpp @@ -69,18 +69,14 @@ AddrStmt* SVFIR::addAddrStmt(NodeID src, NodeID dst) else { AddrStmt* addrPE = new AddrStmt(srcNode, dstNode); - addToStmt2TypeMap(addrPE); - addEdge(srcNode,dstNode, addrPE); + addAddrStmt(addrPE); return addrPE; } } -void SVFIR::addAddrStmtFromDB(AddrStmt* edge) +void SVFIR::addAddrStmt(AddrStmt* edge) { - if(!hasEdge(edge, SVFStmt::Addr)) - { - addToStmt2TypeMap(edge); - addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); - } + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); } /*! @@ -95,19 +91,15 @@ CopyStmt* SVFIR::addCopyStmt(NodeID src, NodeID dst, CopyStmt::CopyKind type) else { CopyStmt* copyPE = new CopyStmt(srcNode, dstNode, type); - addToStmt2TypeMap(copyPE); - addEdge(srcNode,dstNode, copyPE); + addCopyStmt(copyPE); return copyPE; } } -void SVFIR::addCopyStmtFromDB(CopyStmt* edge) +void SVFIR::addCopyStmt(CopyStmt* edge) { - if(!hasEdge(edge, SVFStmt::Copy)) - { - addToStmt2TypeMap(edge); - addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); - } + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); } /*! @@ -121,9 +113,7 @@ PhiStmt* SVFIR::addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred) if(it == phiNodeMap.end()) { PhiStmt* phi = new PhiStmt(resNode, {opNode}, {pred}); - addToStmt2TypeMap(phi); - addEdge(opNode, resNode, phi); - phiNodeMap[resNode] = phi; + addPhiStmt(phi, opNode, resNode); return phi; } else @@ -134,17 +124,17 @@ PhiStmt* SVFIR::addPhiStmt(NodeID res, NodeID opnd, const ICFGNode* pred) } } -void SVFIR::addPhiStmtFromDB(PhiStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addPhiStmt(PhiStmt* edge, SVFVar* src, SVFVar* dst) { SVFVar* opNode = src; SVFVar* resNode = dst; - PHINodeMap::iterator it = phiNodeMap.find(resNode); - if (it == phiNodeMap.end()) - { - addToStmt2TypeMap(edge); - addEdge(opNode, resNode, edge); - phiNodeMap[resNode] = edge; - } + if (Options::ReadFromDB() && phiNodeMap.count(resNode)) + return; + + addToStmt2TypeMap(edge); + addEdge(opNode, resNode, edge); + phiNodeMap[resNode] = edge; + } /*! @@ -162,19 +152,15 @@ SelectStmt* SVFIR::addSelectStmt(NodeID res, NodeID op1, NodeID op2, NodeID cond { std::vector opnds = {op1Node, op2Node}; SelectStmt* select = new SelectStmt(dstNode, opnds, condNode); - addToStmt2TypeMap(select); - addEdge(op1Node, dstNode, select); + addSelectStmt(select, op1Node, dstNode); return select; } } -void SVFIR::addSelectStmtFromDB(SelectStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addSelectStmt(SelectStmt* edge, SVFVar* src, SVFVar* dst) { - if (!hasEdge(edge, SVFStmt::Select)) - { - addToStmt2TypeMap(edge); - addEdge(src, dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); } /*! @@ -191,19 +177,15 @@ CmpStmt* SVFIR::addCmpStmt(NodeID op1, NodeID op2, NodeID dst, u32_t predicate) { std::vector opnds = {op1Node, op2Node}; CmpStmt* cmp = new CmpStmt(dstNode, opnds, predicate); - addToStmt2TypeMap(cmp); - addEdge(op1Node, dstNode, cmp); + addCmpStmt(cmp, op1Node, dstNode); return cmp; } } -void SVFIR::addCmpStmtFromDB(CmpStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addCmpStmt(CmpStmt* edge, SVFVar* src, SVFVar* dst) { - if (!hasEdge(edge,SVFStmt::Cmp)) - { - addToStmt2TypeMap(edge); - addEdge(src, dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); } @@ -221,19 +203,15 @@ BinaryOPStmt* SVFIR::addBinaryOPStmt(NodeID op1, NodeID op2, NodeID dst, u32_t o { std::vector opnds = {op1Node, op2Node}; BinaryOPStmt* binaryOP = new BinaryOPStmt(dstNode, opnds, opcode); - addToStmt2TypeMap(binaryOP); - addEdge(op1Node,dstNode, binaryOP); + addBinaryOPStmt(binaryOP,op1Node,dstNode); return binaryOP; } } -void SVFIR::addBinaryOPStmtFromDB(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addBinaryOPStmt(BinaryOPStmt* edge, SVFVar* src, SVFVar* dst) { - if (!hasEdge(edge, SVFStmt::BinaryOp)) - { - addToStmt2TypeMap(edge); - addEdge(src, dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); } /*! * Add Unary edge @@ -247,19 +225,15 @@ UnaryOPStmt* SVFIR::addUnaryOPStmt(NodeID src, NodeID dst, u32_t opcode) else { UnaryOPStmt* unaryOP = new UnaryOPStmt(srcNode, dstNode, opcode); - addToStmt2TypeMap(unaryOP); - addEdge(srcNode,dstNode, unaryOP); + addUnaryOPStmt(unaryOP, srcNode,dstNode); return unaryOP; } } -void SVFIR::addUnaryOPStmtFromDB(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addUnaryOPStmt(UnaryOPStmt* edge, SVFVar* src, SVFVar* dst) { - if(!hasEdge(edge, SVFStmt::UnaryOp)) - { addToStmt2TypeMap(edge); addEdge(src, dst, edge); - } } /* @@ -274,19 +248,15 @@ BranchStmt* SVFIR::addBranchStmt(NodeID br, NodeID cond, const BranchStmt::SuccA else { BranchStmt* branch = new BranchStmt(brNode, condNode, succs); - addToStmt2TypeMap(branch); - addEdge(condNode,brNode, branch); + addBranchStmt(branch,condNode,brNode); return branch; } } -void SVFIR::addBranchStmtFromDB(BranchStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addBranchStmt(BranchStmt* edge, SVFVar* src, SVFVar* dst) { - if(!hasEdge(edge, SVFStmt::Branch)) - { - addToStmt2TypeMap(edge); - addEdge(src, dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); } /*! @@ -301,19 +271,15 @@ LoadStmt* SVFIR::addLoadStmt(NodeID src, NodeID dst) else { LoadStmt* loadPE = new LoadStmt(srcNode, dstNode); - addToStmt2TypeMap(loadPE); - addEdge(srcNode,dstNode, loadPE); + addLoadStmt(loadPE); return loadPE; } } -void SVFIR::addLoadStmtFromDB(LoadStmt* edge) +void SVFIR::addLoadStmt(LoadStmt* edge) { - if(!hasEdge(edge, SVFStmt::Load)) - { - addToStmt2TypeMap(edge); - addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); - } + addToStmt2TypeMap(edge); + addEdge(edge->getRHSVar(),edge->getLHSVar(), edge); } /*! @@ -329,19 +295,15 @@ StoreStmt* SVFIR::addStoreStmt(NodeID src, NodeID dst, const ICFGNode* curVal) else { StoreStmt* storePE = new StoreStmt(srcNode, dstNode, curVal); - addToStmt2TypeMap(storePE); - addEdge(srcNode,dstNode, storePE); + addStoreStmt(storePE,srcNode,dstNode); return storePE; } } -void SVFIR::addStoreStmtFromDB(StoreStmt* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addStoreStmt(StoreStmt* edge, SVFVar* src, SVFVar* dst) { - if(!hasEdge(edge,SVFStmt::Store)) - { addToStmt2TypeMap(edge); addEdge(src,dst, edge); - } } /*! @@ -356,19 +318,15 @@ CallPE* SVFIR::addCallPE(NodeID src, NodeID dst, const CallICFGNode* cs, const F else { CallPE* callPE = new CallPE(srcNode, dstNode, cs,entry); - addToStmt2TypeMap(callPE); - addEdge(srcNode,dstNode, callPE); + addCallPE(callPE,srcNode,dstNode); return callPE; } } -void SVFIR::addCallPEFromDB(CallPE* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addCallPE(CallPE* edge, SVFVar* src, SVFVar* dst) { - if(!hasEdge(edge, SVFStmt::Call)) - { - addToStmt2TypeMap(edge); - addEdge(src,dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src,dst, edge); } /*! @@ -383,19 +341,15 @@ RetPE* SVFIR::addRetPE(NodeID src, NodeID dst, const CallICFGNode* cs, const Fun else { RetPE* retPE = new RetPE(srcNode, dstNode, cs, exit); - addToStmt2TypeMap(retPE); - addEdge(srcNode,dstNode, retPE); + addRetPE(retPE,srcNode,dstNode); return retPE; } } -void SVFIR::addRetPEFromDB(RetPE* edge, SVFVar* src, SVFVar* dst) +void SVFIR::addRetPE(RetPE* edge, SVFVar* src, SVFVar* dst) { - if(!hasEdge(edge, SVFStmt::Ret)) - { - addToStmt2TypeMap(edge); - addEdge(src, dst, edge); - } + addToStmt2TypeMap(edge); + addEdge(src, dst, edge); } /*! @@ -421,8 +375,7 @@ TDForkPE* SVFIR::addThreadForkPE(NodeID src, NodeID dst, const CallICFGNode* cs, else { TDForkPE* forkPE = new TDForkPE(srcNode, dstNode, cs, entry); - addToStmt2TypeMap(forkPE); - addEdge(srcNode,dstNode, forkPE); + addCallPE(forkPE,srcNode,dstNode); return forkPE; } } @@ -439,8 +392,7 @@ TDJoinPE* SVFIR::addThreadJoinPE(NodeID src, NodeID dst, const CallICFGNode* cs, else { TDJoinPE* joinPE = new TDJoinPE(srcNode, dstNode, cs, exit); - addToStmt2TypeMap(joinPE); - addEdge(srcNode,dstNode, joinPE); + addRetPE(joinPE,srcNode,dstNode); return joinPE; } } @@ -479,21 +431,18 @@ GepStmt* SVFIR::addNormalGepStmt(NodeID src, NodeID dst, const AccessPath& ap) else { GepStmt* gepPE = new GepStmt(baseNode, dstNode, ap); - addToStmt2TypeMap(gepPE); - addEdge(baseNode, dstNode, gepPE); + addGepStmt(gepPE); return gepPE; } } -void SVFIR::addGepStmtFromDB(GepStmt* gepPE) +void SVFIR::addGepStmt(GepStmt* gepPE) { SVFVar* baseNode = gepPE->getRHSVar(); SVFVar* dstNode = gepPE->getLHSVar(); - if (!hasEdge(gepPE, SVFStmt::Gep)) - { - addToStmt2TypeMap(gepPE); - addEdge(baseNode, dstNode, gepPE); - } + addToStmt2TypeMap(gepPE); + addEdge(baseNode, dstNode, gepPE); + } /*! @@ -582,15 +531,13 @@ NodeID SVFIR::getGepObjVar(const BaseObjVar* baseObj, const APOffset& apOffset) } -void SVFIR::addGepObjNodeFromDB(GepObjVar* gepObj) +NodeID SVFIR::addGepObjNode(GepObjVar* gepObj, NodeID base, const APOffset& apOffset) { - NodeID base = gepObj->getBaseNode(); - APOffset apOffset = gepObj->getConstantFieldIdx(); assert(0==GepObjVarMap.count(std::make_pair(base, apOffset)) && "this node should not be created before"); GepObjVarMap[std::make_pair(base, apOffset)] = gepObj->getId(); memToFieldsMap[base].set(gepObj->getId()); - addObjNode(gepObj); + return addObjNode(gepObj); } /*! @@ -602,12 +549,9 @@ NodeID SVFIR::addGepObjNode(const BaseObjVar* baseObj, const APOffset& apOffset, NodeID base = baseObj->getId(); assert(0==GepObjVarMap.count(std::make_pair(base, apOffset)) && "this node should not be created before"); - - GepObjVarMap[std::make_pair(base, apOffset)] = gepId; //ABTest GepObjVar *node = new GepObjVar(baseObj, gepId, apOffset); - memToFieldsMap[base].set(gepId); - return addObjNode(node); + return addGepObjNode(node, base, apOffset); } /*! @@ -825,5 +769,43 @@ void SVFIR::handleBlackHole(bool b) Options::HandBlackHole.setValue(b); } +NodeID SVFIR::addValNode(ValVar* node) +{ + assert(node && "node cannot be nullptr."); + assert(hasGNode(node->getId()) == false && + "This NodeID clashes here. Please check NodeIDAllocator. Switch " + "Strategy::DBUG to SEQ or DENSE"); + if (Options::ReadFromDB() && hasGNode(node->getId())) + { + ValVar* valvar = SVFUtil::cast(getGNode(node->getId())); + valvar->updateSVFValVarFromDB(node->getType(), node->getICFGNode()); + return valvar->getId(); + } + return addNode(node); +} +NodeID SVFIR::addObjNode(ObjVar* node) +{ + assert(node && "node cannot be nullptr."); + assert(hasGNode(node->getId()) == false && + "This NodeID clashes here. Please check NodeIDAllocator. Switch " + "Strategy::DBUG to SEQ or DENSE"); + if (Options::ReadFromDB() && hasGNode(node->getId())) + { + ObjVar* objVar = SVFUtil::cast(getGNode(node->getId())); + objVar->updateObjVarFromDB(node->getType()); + return objVar->getId(); + } + return addNode(node); +} +NodeID SVFIR::addDummyObjNode(DummyObjVar* node) +{ + if (Options::ReadFromDB() && idToObjTypeInfoMap().find(node->getId()) == idToObjTypeInfoMap().end()) + { + ObjTypeInfo* ti = node->getTypeInfo(); + idToObjTypeInfoMap()[node->getId()] = ti; + return addObjNode(node); + } + return addObjNode(node); +} \ No newline at end of file diff --git a/svf/lib/SVFIR/SVFStatements.cpp b/svf/lib/SVFIR/SVFStatements.cpp index 4956003fa..486631c1b 100644 --- a/svf/lib/SVFIR/SVFStatements.cpp +++ b/svf/lib/SVFIR/SVFStatements.cpp @@ -30,7 +30,6 @@ #include "SVFIR/SVFStatements.h" #include "SVFIR/SVFIR.h" #include "Util/Options.h" -#include "SVFIR/GraphDBClient.h" using namespace SVF; using namespace SVFUtil; From 0849c2f713e9a3ab67ef40e1ba1cfb23820b935d Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Sun, 5 Oct 2025 10:41:57 +1100 Subject: [PATCH 12/19] fix ci test failed reslove confilt --- svf/include/Graphs/ICFGNode.h | 4 ++-- svf/include/SVFIR/SVFStatements.h | 1 - svf/include/SVFIR/SVFVariables.h | 28 ++++++++++++++++++++++++++-- 3 files changed, 28 insertions(+), 5 deletions(-) diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index b83b128e5..d0cb86e84 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -370,8 +370,8 @@ class FunExitICFGNode : public InterICFGNode friend class GraphDBClient; protected: - FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb) - : InterICFGNode(id, FunExitBlock), formalRet(nullptr) + FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb, SVFVar* formalRet) + : InterICFGNode(id, FunExitBlock), formalRet(formalRet) { this->fun = f; this->bb = bb; diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index 03600af76..f0c74a19a 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -127,7 +127,6 @@ class SVFStmt : public GenericPAGEdgeTy } public: - // static u32_t totalEdgeNum; ///< Total edge number /// Constructor SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, bool real = true); diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index 6f5ac0e0d..28e7d863d 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -284,6 +284,9 @@ class ValVar: public SVFVar private: const ICFGNode* icfgNode; // icfgnode related to valvar +protected: + /// Constructor to create an empty ValVar (for SVFIRReader/deserialization) + ValVar(NodeID i, PNODEK ty = ValNode) : SVFVar(i, ty), icfgNode(nullptr) {} ValVar(NodeID i, const SVFType* type, PNODEK ty = ValNode) : SVFVar(i, type, ty), icfgNode(nullptr) {} public: @@ -350,6 +353,8 @@ class ObjVar: public SVFVar friend class GepObjVar; protected: + /// Constructor to create an empty ObjVar (for SVFIRReader/deserialization) + ObjVar(NodeID i, PNODEK ty = ObjNode) : SVFVar(i, ty) {} /// Constructor ObjVar(NodeID i, const SVFType* svfType, PNODEK ty = ObjNode) : SVFVar(i, svfType, ty) @@ -485,6 +490,9 @@ class GepValVar: public ValVar const SVFType* gepValType; NodeID llvmVarID; + /// Constructor to create empty GeValVar (for SVFIRReader/deserialization) + GepValVar(NodeID i) : ValVar(i, GepValNode), gepValType{} {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -694,7 +702,7 @@ class BaseObjVar : public ObjVar /// Get obj type const SVFType* getType() const { - return type; + return typeInfo->getType(); } /// Get the number of elements of this object @@ -836,6 +844,10 @@ class GepObjVar: public ObjVar const BaseObjVar* base; + /// Constructor to create empty GepObjVar (for SVFIRReader/deserialization) + // only for reading from file when we don't have BaseObjVar* + GepObjVar(NodeID i, PNODEK ty = GepObjNode) : ObjVar(i, ty), base{} {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -1099,6 +1111,11 @@ class FunObjVar : public BaseObjVar std::vector allArgs; /// all formal arguments of this function const SVFBasicBlock *exitBlock; /// a 'single' basic block having no successors and containing return instruction in a function + +private: + /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) + FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {} + public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -2194,6 +2211,9 @@ class RetValPN : public ValVar private: const FunObjVar* callGraphNode; +private: + /// Constructor to create empty RetValPN (for SVFIRReader/deserialization) + RetValPN(NodeID i) : ValVar(i, RetValNode) {} public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: @@ -2257,6 +2277,10 @@ class VarArgValPN : public ValVar private: const FunObjVar* callGraphNode; +private: + /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization) + VarArgValPN(NodeID i) : ValVar(i, VarargValNode) {} + public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const VarArgValPN*) @@ -2426,4 +2450,4 @@ class DummyObjVar: public BaseObjVar } // End namespace SVF -#endif /* INCLUDE_SVFIR_SVFVARIABLE_H_ */ +#endif /* INCLUDE_SVFIR_SVFVARIABLE_H_ */ \ No newline at end of file From 09ece29f63741506bfa962d9e57e674daabde7cc Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Tue, 7 Oct 2025 11:32:28 +1100 Subject: [PATCH 13/19] fix comments --- svf/include/Graphs/BasicBlockG.h | 21 +-- svf/include/Graphs/CallGraph.h | 14 +- svf/include/Graphs/ICFGNode.h | 46 +++---- svf/include/MemoryModel/AccessPath.h | 3 +- svf/include/SVFIR/SVFIR.h | 10 +- svf/include/SVFIR/SVFStatements.h | 32 +++-- svf/include/SVFIR/SVFType.h | 194 +++++++++++++++------------ svf/include/SVFIR/SVFVariables.h | 149 +++++--------------- svf/include/Util/SVFLoopAndDomInfo.h | 10 +- 9 files changed, 214 insertions(+), 265 deletions(-) diff --git a/svf/include/Graphs/BasicBlockG.h b/svf/include/Graphs/BasicBlockG.h index 78f9c7d82..2507f23cc 100644 --- a/svf/include/Graphs/BasicBlockG.h +++ b/svf/include/Graphs/BasicBlockG.h @@ -99,6 +99,17 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy /// @} + // Getters of predecessor and successor basic blocks, used for writing bb to DB + const std::vector getSuccBBs() const + { + return succBBs; + } + + const std::vector getPredBBs() const + { + return predBBs; + } + public: /// Constructor without name SVFBasicBlock(NodeID id, const FunObjVar* f): GenericBasicBlockNodeTy(id, BasicBlockKd), fun(f) @@ -283,16 +294,6 @@ class SVFBasicBlock : public GenericBasicBlockNodeTy const std::string toString() const; - const std::vector getSuccBBs() const - { - return succBBs; - } - - const std::vector getPredBBs() const - { - return predBBs; - } - }; diff --git a/svf/include/Graphs/CallGraph.h b/svf/include/Graphs/CallGraph.h index 857260c60..c7f129efe 100644 --- a/svf/include/Graphs/CallGraph.h +++ b/svf/include/Graphs/CallGraph.h @@ -314,6 +314,15 @@ class CallGraph : public GenericPTACallGraphTy /// add direct call graph edge from database [only used this function when loading cgEdges from db results] void addDirectCallGraphEdge(CallGraphEdge* cgEdge); + + /// add call graph node from database [only used this function when loading cgNodes from db results] + void addCallGraphNode(CallGraphNode* cgNode); + + /// Whether we have already created this call graph edge, only used when adding new edge from db query results + CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge) const; + + /// Add indirect call graph edge from database [only used this function when loading cgEdges from db results] + void addIndirectCallGraphEdge(CallGraphEdge* cgEdge); public: /// Constructor CallGraph(CGEK k = NormCallGraph); @@ -373,8 +382,6 @@ class CallGraph : public GenericPTACallGraphTy void addCallGraphNode(const FunObjVar* fun); - void addCallGraphNode(CallGraphNode* cgNode); - /// Get call graph node //@{ @@ -427,8 +434,6 @@ class CallGraph : public GenericPTACallGraphTy /// Whether we have already created this call graph edge CallGraphEdge* hasGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId) const; - - CallGraphEdge* hasGraphEdge(CallGraphEdge* cgEdge) const; /// Get call graph edge via nodes CallGraphEdge* getGraphEdge(CallGraphNode* src, CallGraphNode* dst, CallGraphEdge::CEDGEK kind, CallSiteID csId); @@ -473,7 +478,6 @@ class CallGraph : public GenericPTACallGraphTy /// Add indirect call edges //@{ void addIndirectCallGraphEdge(const CallICFGNode* cs,const FunObjVar* callerFun, const FunObjVar* calleeFun); - void addIndirectCallGraphEdge(CallGraphEdge* cgEdge); //@} /// Get callsites invoking the callee diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index d0cb86e84..b59b87d9d 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -208,11 +208,11 @@ class IntraICFGNode : public ICFGNode friend class GraphDBClient; protected: - IntraICFGNode(NodeID id, const SVFBasicBlock* bb, const FunObjVar* funObjVar, bool isReturn): ICFGNode(id, IntraBlock),isRet(isReturn) + IntraICFGNode(NodeID id, const SVFBasicBlock* b, const FunObjVar* f, bool isReturn): ICFGNode(id, IntraBlock),isRet(isReturn) { - this->fun = funObjVar; - this->bb = bb; + this->fun = f; + this->bb = b; } private: @@ -296,11 +296,11 @@ class FunEntryICFGNode : public InterICFGNode friend class GraphDBClient; protected: - FunEntryICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb) + FunEntryICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* b) : InterICFGNode(id, FunEntryBlock) { this->fun = f; - this->bb = bb; + this->bb = b; } public: @@ -370,11 +370,11 @@ class FunExitICFGNode : public InterICFGNode friend class GraphDBClient; protected: - FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* bb, SVFVar* formalRet) + FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* b, SVFVar* formalRet) : InterICFGNode(id, FunExitBlock), formalRet(formalRet) { this->fun = f; - this->bb = bb; + this->bb = b; } private: @@ -454,20 +454,17 @@ class CallICFGNode : public InterICFGNode s32_t virtualFunIdx; /// virtual function index of the virtual table(s) at a virtual call std::string funNameOfVcall; /// the function name of this virtual call const SVFVar* indFunPtr; - - /// Constructor to create empty CallICFGNode (for SVFIRReader/deserialization) - CallICFGNode(NodeID id) : InterICFGNode(id, FunCallBlock), ret{} {} - CallICFGNode(NodeID id, const SVFBasicBlock* bb, const SVFType* type, - const FunObjVar* fun, const FunObjVar* cf, const RetICFGNode* ret, + CallICFGNode(NodeID id, const SVFBasicBlock* b, const SVFType* ty, + const FunObjVar* f, const FunObjVar* cf, const RetICFGNode* ret, bool iv, bool ivc, s32_t vfi, SVFVar* vtabPtr, const std::string& fnv) : InterICFGNode(id, FunCallBlock), ret(ret), calledFunc(cf), isvararg(iv), isVirCallInst(ivc), vtabPtr(vtabPtr), virtualFunIdx(vfi), funNameOfVcall(fnv) { - this->fun = fun; - this->bb = bb; - this->type = type; + this->fun = f; + this->bb = b; + this->type = ty; } @@ -643,12 +640,18 @@ class RetICFGNode : public InterICFGNode friend class GraphDBClient; protected: - RetICFGNode(NodeID id, const SVFType* type, const SVFBasicBlock* bb, const FunObjVar* funObjVar) : + RetICFGNode(NodeID id, const SVFType* ty, const SVFBasicBlock* b, const FunObjVar* f) : InterICFGNode(id, FunRetBlock), actualRet(nullptr), callBlockNode(nullptr) { - this->fun = funObjVar; - this->bb = bb; - this->type = type; + this->fun = f; + this->bb = b; + this->type = ty; + } + + /// Add call block node from database for the new RetICFGNode [only used this function when loading from db results] + inline void addCallBlockNodeFromDB(const CallICFGNode* cb) + { + callBlockNode = cb; } private: @@ -680,11 +683,6 @@ class RetICFGNode : public InterICFGNode actualRet = ar; } - inline void addCallBlockNodeFromDB(const CallICFGNode* cb) - { - callBlockNode = cb; - } - ///Methods for support type inquiry through isa, cast, and dyn_cast: //@{ static inline bool classof(const RetICFGNode *) diff --git a/svf/include/MemoryModel/AccessPath.h b/svf/include/MemoryModel/AccessPath.h index 17fab6160..9edc6df0e 100644 --- a/svf/include/MemoryModel/AccessPath.h +++ b/svf/include/MemoryModel/AccessPath.h @@ -51,7 +51,7 @@ class SVFVar; */ class AccessPath { - + friend class GraphDBClient; public: enum LSRelation { @@ -161,6 +161,7 @@ class AccessPath /// Dump location set std::string dump() const; +protected: inline void addIdxOperandPair(std::pair pair) { idxOperandPairs.push_back(pair); diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index a66839fce..550a0ad75 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -511,6 +511,11 @@ class SVFIR : public IRGraph NodeID addDummyObjNode(DummyObjVar* node); NodeID addGepObjNode(GepObjVar* gepObj, NodeID base, const APOffset& apOffset); + + inline void addGepValObjFromDB(NodeID curInstID, const GepValVar* gepValvar) + { + GepValObjMap[curInstID][std::make_pair(gepValvar->getBaseNode()->getId(), gepValvar->getAccessPath())] = gepValvar->getId(); + } private: @@ -789,11 +794,6 @@ class SVFIR : public IRGraph { callSiteSet.insert(call); } - - inline void addGepValObjFromDB(NodeID curInstID, const GepValVar* gepValvar) - { - GepValObjMap[curInstID][std::make_pair(gepValvar->getBaseNode()->getId(), gepValvar->getAccessPath())] = gepValvar->getId(); - } /// Add an edge into SVFIR //@{ /// Add Address edge diff --git a/svf/include/SVFIR/SVFStatements.h b/svf/include/SVFIR/SVFStatements.h index f0c74a19a..8c552e274 100644 --- a/svf/include/SVFIR/SVFStatements.h +++ b/svf/include/SVFIR/SVFStatements.h @@ -51,10 +51,6 @@ class SVFBasicBlock; typedef GenericEdge GenericPAGEdgeTy; class SVFStmt : public GenericPAGEdgeTy { - friend class AssignStmt; - friend class MultiOpndStmt; - friend class UnaryOPStmt; - friend class BranchStmt; friend class GraphDBClient; public: @@ -96,26 +92,41 @@ class SVFStmt : public GenericPAGEdgeTy SVFStmt(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, bool real = true); + /** + * Set the SVF BasicBlock for the new statements, this is used when loading statements from DB + */ inline void setBasicBlock(const SVFBasicBlock* bb) { basicBlock = bb; } + /** + * set the call edge lanbel counter for the new statements, this is used when loading statements from DB + */ inline void setCallEdgeLabelCounter(u64_t counter) { callEdgeLabelCounter = counter; } + /** + * set the store edge lanbel counter for the new statements, this is used when loading statements from DB + */ inline void setStoreEdgeLabelCounter(u64_t counter) { storeEdgeLabelCounter = counter; } + /** + * set the multi operand edge lanbel counter for the new statements, this is used when loading statements from DB + */ inline void setMultiOpndLabelCounter(u64_t counter) { multiOpndLabelCounter = counter; } + /** + * Add a call site Instruction to label mapping, this is used when loading statements from DB + */ static inline void addInst2Labeled(const ICFGNode* cs, u32_t label) { inst2LabelMap.emplace(cs, label); @@ -295,13 +306,6 @@ class SVFStmt : public GenericPAGEdgeTy class AssignStmt : public SVFStmt { friend class GraphDBClient; - friend class AddrStmt; - friend class CopyStmt; - friend class StoreStmt; - friend class LoadStmt; - friend class GepStmt; - friend class CallPE; - friend class RetPE; private: AssignStmt(); ///< place holder @@ -681,7 +685,6 @@ class GepStmt: public AssignStmt class CallPE: public AssignStmt { friend class GraphDBClient; - friend class TDForkPE; protected: CallPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, @@ -743,7 +746,6 @@ class CallPE: public AssignStmt class RetPE: public AssignStmt { friend class GraphDBClient; - friend class TDJoinPE; protected: RetPE(SVFVar* s, SVFVar* d, GEdgeFlag k, EdgeID eid, SVFVar* value, ICFGNode* icfgNode, const CallICFGNode* call, @@ -806,10 +808,6 @@ class RetPE: public AssignStmt class MultiOpndStmt : public SVFStmt { friend class GraphDBClient; - friend class PhiStmt; - friend class SelectStmt; - friend class CmpStmt; - friend class BinaryOPStmt; diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index dfbab669e..6346d3b2f 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -46,6 +46,33 @@ class SVFPointerType; class StInfo { + friend class GraphDBClient; + friend class IRGraph; + +protected: + StInfo (u32_t id, std::vector fldIdxVec, std::vector elemIdxVec, Map fldIdx2TypeMap, + std::vector finfo,u32_t stride,u32_t numOfFlattenElements,u32_t numOfFlattenFields, std::vector flattenElementTypes ) + :StInfoId(id), fldIdxVec(fldIdxVec), elemIdxVec(elemIdxVec), fldIdx2TypeMap(fldIdx2TypeMap), finfo(finfo), stride(stride), + numOfFlattenElements(numOfFlattenElements), numOfFlattenFields(numOfFlattenFields), flattenElementTypes(flattenElementTypes) + { + + } + + inline const u32_t getStinfoId() const + { + return StInfoId; + } + + inline const Map& getFldIdx2TypeMap() const + { + return fldIdx2TypeMap; + } + + inline void setStinfoId(u32_t id) + { + StInfoId = id; + } + private: u32_t StInfoId; /// flattened field indices of a struct (ignoring arrays) @@ -79,13 +106,6 @@ class StInfo { } - StInfo (u32_t id, std::vector fldIdxVec, std::vector elemIdxVec, Map fldIdx2TypeMap, - std::vector finfo,u32_t stride,u32_t numOfFlattenElements,u32_t numOfFlattenFields, std::vector flattenElementTypes ) - :StInfoId(id), fldIdxVec(fldIdxVec), elemIdxVec(elemIdxVec), fldIdx2TypeMap(fldIdx2TypeMap), finfo(finfo), stride(stride), - numOfFlattenElements(numOfFlattenElements), numOfFlattenFields(numOfFlattenFields), flattenElementTypes(flattenElementTypes) - { - - } /// Destructor ~StInfo() = default; @@ -130,15 +150,6 @@ class StInfo { return finfo; } - inline const u32_t getStinfoId() const - { - return StInfoId; - } - - inline const Map& getFldIdx2TypeMap() const - { - return fldIdx2TypeMap; - } //@} /// Add field index and element index and their corresponding type @@ -151,11 +162,6 @@ class StInfo numOfFlattenElements = ne; } - inline void setStinfoId(u32_t id) - { - StInfoId = id; - } - /// Return number of elements after flattening (including array elements) inline u32_t getNumOfFlattenElements() const { @@ -193,6 +199,20 @@ class SVFType SVFOtherTy, }; +protected: + + /// set svfptrty and svfi8ty when initializing SVFType from db query results + inline static void setSVFPtrType(SVFType* ptrTy) + { + svfPtrTy = ptrTy; + } + + inline static void setSVFInt8Type(SVFType* i8Ty) + { + svfI8Ty = i8Ty; + } + + public: inline static SVFType* getSVFPtrType() @@ -201,22 +221,12 @@ class SVFType return svfPtrTy; } - inline static void setSVFPtrType(SVFType* ptrTy) - { - svfPtrTy = ptrTy; - } - inline static SVFType* getSVFInt8Type() { assert(svfI8Ty && "int8 type not set?"); return svfI8Ty; } - inline static void setSVFInt8Type(SVFType* i8Ty) - { - svfI8Ty = i8Ty; - } - private: static SVFType* svfPtrTy; ///< ptr type @@ -307,18 +317,20 @@ std::ostream& operator<<(std::ostream& os, const SVFType& type); class SVFPointerType : public SVFType { -public: - SVFPointerType(u32_t i, u32_t byteSize = 1) - : SVFType(true, SVFPointerTy, i, byteSize) - { - } - + friend class GraphDBClient; +protected: SVFPointerType(u32_t id, u32_t byteSize, bool isSingleValTy) : SVFType(isSingleValTy, SVFPointerTy, id, byteSize) { } +public: + SVFPointerType(u32_t i, u32_t byteSize = 1) + : SVFType(true, SVFPointerTy, i, byteSize) + { + } + static inline bool classof(const SVFType* node) { return node->getKind() == SVFPointerTy; @@ -329,17 +341,25 @@ class SVFPointerType : public SVFType class SVFIntegerType : public SVFType { + friend class GraphDBClient; private: short signAndWidth; ///< For printing -public: - SVFIntegerType(u32_t i, u32_t byteSize = 1) : SVFType(true, SVFIntegerTy, i, byteSize) {} +protected: SVFIntegerType(u32_t i, u32_t byteSize, bool isSingleValTy,short signAndWidth) : SVFType(isSingleValTy, SVFIntegerTy, i, byteSize) { this->signAndWidth = signAndWidth; } + + short getSignAndWidth() const + { + return signAndWidth; + } + +public: + SVFIntegerType(u32_t i, u32_t byteSize = 1) : SVFType(true, SVFIntegerTy, i, byteSize) {} static inline bool classof(const SVFType* node) { return node->getKind() == SVFIntegerTy; @@ -352,11 +372,6 @@ class SVFIntegerType : public SVFType signAndWidth = sw; } - short getSignAndWidth() const - { - return signAndWidth; - } - bool isSigned() const { return signAndWidth < 0; @@ -371,10 +386,13 @@ class SVFFunctionType : public SVFType std::vector params; bool varArg; -public: - SVFFunctionType(u32_t i, const SVFType* rt, const std::vector& p, bool isvararg) - : SVFType(false, SVFFunctionTy, i, 1), retTy(rt), params(p), varArg(isvararg) +protected: + /** + * Set return type of function, this is used when loading from DB + */ + const void setReturnType(const SVFType* rt) { + retTy = rt; } SVFFunctionType(u32_t id, bool svt, u32_t byteSize) @@ -382,6 +400,17 @@ class SVFFunctionType : public SVFType { } + void addParamType(const SVFType* type) + { + params.push_back(type); + } + +public: + SVFFunctionType(u32_t i, const SVFType* rt, const std::vector& p, bool isvararg) + : SVFType(false, SVFFunctionTy, i, 1), retTy(rt), params(p), varArg(isvararg) + { + } + static inline bool classof(const SVFType* node) { return node->getKind() == SVFFunctionTy; @@ -391,11 +420,6 @@ class SVFFunctionType : public SVFType return retTy; } - const void setReturnType(const SVFType* rt) - { - retTy = rt; - } - const std::vector& getParamTypes() const { return params; @@ -406,16 +430,25 @@ class SVFFunctionType : public SVFType return varArg; } - void addParamType(const SVFType* type) - { - params.push_back(type); - } - void print(std::ostream& os) const override; }; class SVFStructType : public SVFType { + friend class GraphDBClient; + +protected: + SVFStructType(u32_t i, bool svt, u32_t byteSize, std::string name) : SVFType(svt, SVFStructTy, i, byteSize),name(name) {} + + const std::string& getName() const + { + return name; + } + + void addFieldsType(const SVFType* type) + { + fields.push_back(type); + } private: /// @brief Field for printing & debugging @@ -428,8 +461,6 @@ class SVFStructType : public SVFType { } - SVFStructType(u32_t i, bool svt, u32_t byteSize, std::string name) : SVFType(svt, SVFStructTy, i, byteSize),name(name) {} - static inline bool classof(const SVFType* node) { return node->getKind() == SVFStructTy; @@ -442,11 +473,6 @@ class SVFStructType : public SVFType return name; } - const std::string& getName() const - { - return name; - } - void setName(const std::string& structName) { name = structName; @@ -461,15 +487,22 @@ class SVFStructType : public SVFType return fields; } - void addFieldsType(const SVFType* type) - { - fields.push_back(type); - } - }; class SVFArrayType : public SVFType { + friend class GraphDBClient; + +protected: + SVFArrayType(u32_t id, bool svt, u32_t byteSize, unsigned elemNum) + : SVFType(svt, SVFArrayTy, id, byteSize), numOfElement(elemNum), typeOfElement(nullptr) + { + + } + const unsigned getNumOfElement() const + { + return numOfElement; + } private: unsigned numOfElement; /// For printing & debugging @@ -479,11 +512,6 @@ class SVFArrayType : public SVFType SVFArrayType(u32_t i, u32_t byteSize = 1) : SVFType(false, SVFArrayTy, i, byteSize), numOfElement(0), typeOfElement(nullptr) { - } - SVFArrayType(u32_t id, bool svt, u32_t byteSize, unsigned elemNum) - : SVFType(svt, SVFArrayTy, id, byteSize), numOfElement(elemNum), typeOfElement(nullptr) - { - } static inline bool classof(const SVFType* node) @@ -508,23 +536,25 @@ class SVFArrayType : public SVFType numOfElement = elemNum; } - const unsigned getNumOfElement() const - { - return numOfElement; - } - }; class SVFOtherType : public SVFType { + friend class GraphDBClient; + +protected: + SVFOtherType(u32_t i, bool isSingleValueTy, u32_t byteSize, std::string repr) : SVFType(isSingleValueTy, SVFOtherTy, i, byteSize),repr(repr) {} + const std::string& getRepr() const + { + return repr; + } private: std::string repr; /// Field representation for printing public: SVFOtherType(u32_t i, bool isSingleValueTy, u32_t byteSize = 1) : SVFType(isSingleValueTy, SVFOtherTy, i, byteSize) {} - SVFOtherType(u32_t i, bool isSingleValueTy, u32_t byteSize, std::string repr) : SVFType(isSingleValueTy, SVFOtherTy, i, byteSize),repr(repr) {} static inline bool classof(const SVFType* node) { @@ -535,10 +565,6 @@ class SVFOtherType : public SVFType { return repr; } - const std::string& getRepr() const - { - return repr; - } void setRepr(std::string&& r) { diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index 28e7d863d..16bf1a3ff 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -52,6 +52,7 @@ class SVFVar : public GenericPAGNodeTy friend class IRGraph; friend class SVFIR; friend class VFG; + friend class GraphDBClient; public: /// Node kinds for SVFIR variables: @@ -71,8 +72,16 @@ class SVFVar : public GenericPAGNodeTy SVFStmt::KindToSVFStmtMapTy InEdgeKindToSetMap; SVFStmt::KindToSVFStmtMapTy OutEdgeKindToSetMap; - /// Empty constructor for deserialization - SVFVar(NodeID i, PNODEK k) : GenericPAGNodeTy(i, k) {} + inline const SVFStmt::KindToSVFStmtMapTy& getInEdgeKindToSetMap() const + { + return InEdgeKindToSetMap; + } + + + inline const SVFStmt::KindToSVFStmtMapTy& getOutEdgeKindToSetMap() const + { + return OutEdgeKindToSetMap; + } public: @@ -107,16 +116,6 @@ class SVFVar : public GenericPAGNodeTy return nullptr; } - inline const SVFStmt::KindToSVFStmtMapTy& getInEdgeKindToSetMap() const - { - return InEdgeKindToSetMap; - } - - inline const SVFStmt::KindToSVFStmtMapTy& getOutEdgeKindToSetMap() const - { - return OutEdgeKindToSetMap; - } - /// Edge accessors and checkers //@{ inline SVFStmt::SVFStmtSetTy& getIncomingEdges(SVFStmt::PEDGEK kind) @@ -272,21 +271,10 @@ class SVFVar : public GenericPAGNodeTy class ValVar: public SVFVar { friend class GraphDBClient; - friend class RetValPN; - friend class ConstDataValVar; - friend class ArgValVar; - friend class GepValVar; - friend class DummyValVar; - friend class FunValVar; - friend class GlobalValVar; - friend class ConstAggValVar; - friend class VarArgValPN; private: const ICFGNode* icfgNode; // icfgnode related to valvar protected: - /// Constructor to create an empty ValVar (for SVFIRReader/deserialization) - ValVar(NodeID i, PNODEK ty = ValNode) : SVFVar(i, ty), icfgNode(nullptr) {} ValVar(NodeID i, const SVFType* type, PNODEK ty = ValNode) : SVFVar(i, type, ty), icfgNode(nullptr) {} public: @@ -349,12 +337,8 @@ class ValVar: public SVFVar class ObjVar: public SVFVar { friend class GraphDBClient; - friend class BaseObjVar; - friend class GepObjVar; protected: - /// Constructor to create an empty ObjVar (for SVFIRReader/deserialization) - ObjVar(NodeID i, PNODEK ty = ObjNode) : SVFVar(i, ty) {} /// Constructor ObjVar(NodeID i, const SVFType* svfType, PNODEK ty = ObjNode) : SVFVar(i, svfType, ty) @@ -413,8 +397,6 @@ class ArgValVar: public ValVar u32_t argNo; protected: - /// Constructor to create function argument (for SVFIRReader/deserialization) - ArgValVar(NodeID i, PNODEK ty = ArgValNode) : ValVar(i, ty) {} ArgValVar(NodeID i, const SVFType* type, u32_t argNo, PNODEK ty = ArgValNode) : ValVar(i, type, ty), argNo(argNo) {} public: @@ -483,6 +465,13 @@ class ArgValVar: public ValVar */ class GepValVar: public ValVar { + friend class GraphDBClient; + +protected: + GepValVar(NodeID i, const SVFType* type, const SVFType* gepValType, PNODEK ty = GepValNode) + : ValVar(i, type, GepValNode), gepValType(gepValType) + { + } private: AccessPath ap; // AccessPath @@ -490,8 +479,6 @@ class GepValVar: public ValVar const SVFType* gepValType; NodeID llvmVarID; - /// Constructor to create empty GeValVar (for SVFIRReader/deserialization) - GepValVar(NodeID i) : ValVar(i, GepValNode), gepValType{} {} public: /// Methods for support type inquiry through isa, cast, and dyn_cast: @@ -531,10 +518,6 @@ class GepValVar: public ValVar /// Constructor GepValVar(const ValVar* baseNode, NodeID i, const AccessPath& ap, const SVFType* ty, const ICFGNode* node); - GepValVar(NodeID i, const SVFType* type, const SVFType* gepValType, PNODEK ty = GepValNode) - : ValVar(i, type, GepValNode), gepValType(gepValType) - { - } /// offset of the base value variable inline APOffset getConstantFieldIdx() const @@ -609,14 +592,7 @@ class GepValVar: public ValVar class BaseObjVar : public ObjVar { friend class SVFIRBuilder; - friend class ConstDataObjVar; - friend class DummyObjVar; - friend class ConstAggObjVar; - friend class GlobalObjVar; - friend class FunObjVar; friend class GraphDBClient; - friend class StackObjVar; - friend class HeapObjVar; private: ObjTypeInfo* typeInfo; @@ -624,8 +600,6 @@ class BaseObjVar : public ObjVar const ICFGNode* icfgNode; /// ICFGNode related to the creation of this object protected: - /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) - BaseObjVar(NodeID i, const ICFGNode* node, PNODEK ty = BaseObjNode) : ObjVar(i, ty), icfgNode(node) {} BaseObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = BaseObjNode) : ObjVar(i, type, ty), typeInfo(typeInfo), icfgNode(nullptr) {} public: @@ -844,10 +818,6 @@ class GepObjVar: public ObjVar const BaseObjVar* base; - /// Constructor to create empty GepObjVar (for SVFIRReader/deserialization) - // only for reading from file when we don't have BaseObjVar* - GepObjVar(NodeID i, PNODEK ty = GepObjNode) : ObjVar(i, ty), base{} {} - public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -949,9 +919,6 @@ class HeapObjVar: public BaseObjVar friend class GraphDBClient; protected: - /// Constructor to create heap object var - HeapObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, HeapObjNode) {} - HeapObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, PNODEK ty = HeapObjNode) : BaseObjVar(i, type, ti, ty) {} public: @@ -1013,8 +980,6 @@ class StackObjVar: public BaseObjVar friend class GraphDBClient; protected: - /// Constructor to create stack object var - StackObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, StackObjNode) {} StackObjVar(NodeID i, const SVFType* type, ObjTypeInfo* ti, PNODEK ty = StackObjNode) : BaseObjVar(i, type, ti, ty) {} @@ -1088,6 +1053,14 @@ class FunObjVar : public BaseObjVar { loopAndDom = ld; } + inline bool getIsNotRet() const + { + return isNotRet; + } + inline const std::vector &getArgs() const + { + return allArgs; + } public: typedef SVFLoopAndDomInfo::BBSet BBSet; @@ -1112,10 +1085,6 @@ class FunObjVar : public BaseObjVar const SVFBasicBlock *exitBlock; /// a 'single' basic block having no successors and containing return instruction in a function -private: - /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) - FunObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i,node, FunObjNode) {} - public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -1200,10 +1169,6 @@ class FunObjVar : public BaseObjVar return !isNotRet; } - inline bool getIsNotRet() const - { - return isNotRet; - } /// Returns the FunctionType inline const SVFFunctionType* getFunctionType() const { @@ -1334,11 +1299,6 @@ class FunObjVar : public BaseObjVar assert (idx < allArgs.size() && "getArg() out of range!"); return allArgs[idx]; } - - inline const std::vector &getArgs() const - { - return allArgs; - } inline const SVFBasicBlock* front() const { return getEntryBlock(); @@ -1375,6 +1335,10 @@ class FunValVar : public ValVar protected: /// Constructor to create empty FunValNode (for GraphDBClient) FunValVar(NodeID i, const SVFType* type, PNODEK ty = FunValNode) : ValVar(i, type, ty) {} + inline void setFunction(const FunObjVar* cgn) + { + funObjVar = cgn; + } private: const FunObjVar* funObjVar; @@ -1418,10 +1382,6 @@ class FunValVar : public ValVar return true; } - inline void setFunction(const FunObjVar* cgn) - { - funObjVar = cgn; - } virtual const std::string toString() const; }; @@ -1528,11 +1488,7 @@ class ConstAggValVar: public ValVar class ConstDataValVar : public ValVar { - friend class ConstNullPtrValVar; friend class GraphDBClient; - friend class BlackHoleValVar; - friend class ConstFPValVar; - friend class ConstIntValVar; protected: /// Constructor @@ -1590,6 +1546,7 @@ class ConstDataValVar : public ValVar class BlackHoleValVar : public ConstDataValVar { + friend class GraphDBClient; public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -1826,10 +1783,6 @@ class GlobalObjVar : public BaseObjVar { } -private: - /// Constructor to create empty ObjVar (for SVFIRReader/deserialization) - GlobalObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, GlobalObjNode) {} - public: /// Methods for support type inquiry through isa, cast, and dyn_cast: //@{ @@ -1932,14 +1885,9 @@ class ConstAggObjVar : public BaseObjVar class ConstDataObjVar : public BaseObjVar { - friend class ConstNullPtrObjVar; - friend class ConstIntObjVar; friend class GraphDBClient; - friend class ConstFPObjVar; protected: - /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) - ConstDataObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, ConstDataObjNode) {} ConstDataObjVar(NodeID i, const SVFType* svfType, ObjTypeInfo* typeInfo, PNODEK ty = ConstDataObjNode) : BaseObjVar(i, svfType, typeInfo, ty) { @@ -2005,10 +1953,6 @@ class ConstFPObjVar : public ConstDataObjVar { } -private: - /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) - ConstFPObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} - private: float dval; @@ -2074,9 +2018,6 @@ class ConstIntObjVar : public ConstDataObjVar { } -private: - /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) - ConstIntObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} private: u64_t zval; @@ -2147,9 +2088,6 @@ class ConstNullPtrObjVar : public ConstDataObjVar protected: /// Constructor to create empty DummyObjVar (for GraphDBClient) ConstNullPtrObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = ConstNullptrObjNode) : ConstDataObjVar(i, type, typeInfo, ty) {} -private: - /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) - ConstNullPtrObjVar(NodeID i, const ICFGNode* node) : ConstDataObjVar(i, node) {} public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: @@ -2208,12 +2146,13 @@ class RetValPN : public ValVar protected: /// Constructor to create empty RetValPN (for GraphDBClient) RetValPN(NodeID i, const SVFType* type, PNODEK ty = RetValNode) : ValVar(i, type, ty) {} + inline void setCallGraphNode(const FunObjVar* node) + { + callGraphNode = node; + } private: const FunObjVar* callGraphNode; -private: - /// Constructor to create empty RetValPN (for SVFIRReader/deserialization) - RetValPN(NodeID i) : ValVar(i, RetValNode) {} public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: @@ -2248,11 +2187,6 @@ class RetValPN : public ValVar return callGraphNode; } - inline void setCallGraphNode(const FunObjVar* node) - { - callGraphNode = node; - } - virtual const FunObjVar* getFunction() const; virtual bool isPointer() const; @@ -2277,10 +2211,6 @@ class VarArgValPN : public ValVar private: const FunObjVar* callGraphNode; -private: - /// Constructor to create empty VarArgValPN (for SVFIRReader/deserialization) - VarArgValPN(NodeID i) : ValVar(i, VarargValNode) {} - public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const VarArgValPN*) @@ -2313,11 +2243,6 @@ class VarArgValPN : public ValVar virtual const FunObjVar* getFunction() const; - inline void setCallGraphNode(const FunObjVar* node) - { - callGraphNode = node; - } - /// Return name of a LLVM value const std::string getValueName() const; @@ -2395,10 +2320,6 @@ class DummyObjVar: public BaseObjVar /// Constructor to create empty DummyObjVar (for GraphDBClient) DummyObjVar(NodeID i, const SVFType* type, ObjTypeInfo* typeInfo, PNODEK ty = DummyObjNode) : BaseObjVar(i, type, typeInfo, ty) {} -private: - /// Constructor to create empty DummyObjVar (for SVFIRReader/deserialization) - DummyObjVar(NodeID i, const ICFGNode* node) : BaseObjVar(i, node, DummyObjNode) {} - public: //@{ Methods for support type inquiry through isa, cast, and dyn_cast: static inline bool classof(const DummyObjVar*) diff --git a/svf/include/Util/SVFLoopAndDomInfo.h b/svf/include/Util/SVFLoopAndDomInfo.h index 57ca4bb1b..37d90a0e9 100644 --- a/svf/include/Util/SVFLoopAndDomInfo.h +++ b/svf/include/Util/SVFLoopAndDomInfo.h @@ -87,6 +87,11 @@ inline void setBB2PIdom(Map& bb2PIdo bb2PIdom = bb2PIdomMap; } +inline const Map& getBB2LoopMap() const +{ + return bb2LoopMap; +} + public: SVFLoopAndDomInfo() { @@ -103,11 +108,6 @@ inline void setBB2PIdom(Map& bb2PIdo { return dfBBsMap; } - - inline const Map& getBB2LoopMap() const - { - return bb2LoopMap; - } inline bool hasLoopInfo(const SVFBasicBlock* bb) const { From 899b55555383d2c92d774e602cfb2dcdeaf00c1e Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 27 Oct 2025 08:15:48 +1100 Subject: [PATCH 14/19] updte chg and saber --- svf-llvm/include/SVF-LLVM/SVFIRBuilder.h | 1 + svf-llvm/lib/SVFIRBuilder.cpp | 18 ++++++++++--- svf-llvm/tools/SABER/saber.cpp | 18 +++++++++++-- svf/include/Graphs/CHG.h | 1 + svf/include/SVFIR/SVFIR.h | 6 +++++ svf/lib/SABER/LeakChecker.cpp | 32 +++++++++++++++++++++--- 6 files changed, 67 insertions(+), 9 deletions(-) diff --git a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h index dc79337ff..e337475e1 100644 --- a/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h +++ b/svf-llvm/include/SVF-LLVM/SVFIRBuilder.h @@ -46,6 +46,7 @@ namespace SVF */ class SVFIRBuilder: public llvm::InstVisitor { +friend class GraphDBSVFIRBuilder; private: SVFIR* pag; diff --git a/svf-llvm/lib/SVFIRBuilder.cpp b/svf-llvm/lib/SVFIRBuilder.cpp index 24c95560e..2e6168ffa 100644 --- a/svf-llvm/lib/SVFIRBuilder.cpp +++ b/svf-llvm/lib/SVFIRBuilder.cpp @@ -57,11 +57,21 @@ SVFIR* SVFIRBuilder::build() DBOUT(DGENERAL, outs() << pasMsg("\t Building SVFIR ...\n")); - // We read SVFIR from a user-defined txt instead of parsing SVFIR from LLVM IR - if (SVFIR::pagReadFromTXT()) + if (Options::ReadFromDB()) { - PAGBuilderFromFile fileBuilder(SVFIR::pagFileName()); - return fileBuilder.build(); + GraphDBClient::getInstance().readSVFTypesFromDB(dbConnection, "SVFType", pag); + GraphDBClient::getInstance().initialSVFPAGNodesFromDB(dbConnection, "PAG",pag); + GraphDBClient::getInstance().readBasicBlockGraphFromDB(dbConnection, "BasicBlockGraph"); + CHGraph* chg = GraphDBClient::getInstance().buildCHGraphFromDB(dbConnection, "CHG", pag); + pag->setCHG(chg); + ICFG* icfg = GraphDBClient::getInstance().buildICFGFromDB(dbConnection, "ICFG", pag); + pag->icfg = icfg; + CallGraph* callGraph = GraphDBClient::getInstance().buildCallGraphFromDB(dbConnection,"CallGraph",pag); + pag->callGraph = callGraph; + GraphDBClient::getInstance().updatePAGNodesFromDB(dbConnection, "PAG", pag); + GraphDBClient::getInstance().loadSVFPAGEdgesFromDB(dbConnection, "PAG",pag); + GraphDBClient::getInstance().parseSVFStmtsForICFGNodeFromDBResult(pag); + return pag; } // If the SVFIR has been built before, then we return the unique SVFIR of the program diff --git a/svf-llvm/tools/SABER/saber.cpp b/svf-llvm/tools/SABER/saber.cpp index 15555a4bd..a0d1f5c2e 100644 --- a/svf-llvm/tools/SABER/saber.cpp +++ b/svf-llvm/tools/SABER/saber.cpp @@ -47,9 +47,23 @@ int main(int argc, char ** argv) argc, argv, "Source-Sink Bug Detector", "[options] " ); - LLVMModuleSet::buildSVFModule(moduleNameVec); SVFIRBuilder builder; - SVFIR* pag = builder.build(); + SVFIR* pag; + + if (Options::ReadFromDB()) + { + pag->setPagFromTXT("ReadFromDB"); + } + else + { + if (Options::WriteAnder() == "ir_annotator") + { + LLVMModuleSet::preProcessBCs(moduleNameVec); + } + + LLVMModuleSet::buildSVFModule(moduleNameVec); + } + pag = builder.build(); std::unique_ptr saber; diff --git a/svf/include/Graphs/CHG.h b/svf/include/Graphs/CHG.h index eeb9860b5..6723cba0b 100644 --- a/svf/include/Graphs/CHG.h +++ b/svf/include/Graphs/CHG.h @@ -240,6 +240,7 @@ typedef GenericGraph GenericCHGraphTy; class CHGraph: public CommonCHGraph, public GenericCHGraphTy { friend class CHGBuilder; + friend class GraphDBClient; public: typedef Set CHNodeSetTy; diff --git a/svf/include/SVFIR/SVFIR.h b/svf/include/SVFIR/SVFIR.h index 550a0ad75..46aede3ad 100644 --- a/svf/include/SVFIR/SVFIR.h +++ b/svf/include/SVFIR/SVFIR.h @@ -47,6 +47,7 @@ class SVFIR : public IRGraph friend class TypeBasedHeapCloning; friend class BVDataPTAImpl; friend class GraphDBClient; + friend class GraphDBSVFIRBuilder; public: typedef Set CallSiteSet; @@ -182,6 +183,11 @@ class SVFIR : public IRGraph return callGraph; } + inline void setCallGraph(CallGraph* cg) + { + callGraph = cg; + } + const FunObjVar* getFunObjVar(const std::string& name); inline const std::string& getModuleIdentifier() const diff --git a/svf/lib/SABER/LeakChecker.cpp b/svf/lib/SABER/LeakChecker.cpp index 1b12ec22d..48ad2ae47 100644 --- a/svf/lib/SABER/LeakChecker.cpp +++ b/svf/lib/SABER/LeakChecker.cpp @@ -230,16 +230,31 @@ void LeakChecker::validateSuccessTests(const SVFGNode* source, const FunObjVar* if (success) { - outs() << sucMsg("\t SUCCESS :") << funName << " check getId() + if (!Options::ReadFromDB()) + { + outs() << sucMsg("\t SUCCESS :") << funName << " check getId() << ", cs id:" << (getSrcCSID(source))->valueOnlyToString() << "> at (" << cs->getSourceLoc() << ")\n"; + } + else + { + outs() << sucMsg("\t SUCCESS :") << funName<<"\n"; + } } else { - SVFUtil::errs() << errMsg("\t FAILURE :") << funName << " check getId() + if (!Options::ReadFromDB()) + { + SVFUtil::errs() << errMsg("\t FAILURE :") << funName << " check getId() << ", cs id:" << (getSrcCSID(source))->valueOnlyToString() << "> at (" << cs->getSourceLoc() << ")\n"; - assert(false && "test case failed!"); + assert(false && "test case failed!"); + } + else + { + SVFUtil::errs() << errMsg("\t FAILURE :") << funName << "\n"; + assert(false && "test case failed!"); + } } } @@ -280,12 +295,23 @@ void LeakChecker::validateExpectedFailureTests(const SVFGNode* source, const Fun if (expectedFailure) { + if (Options::ReadFromDB()) + { + outs() << sucMsg("\t EXPECTED-FAILURE :") << funName <<"\n"; + return; + } outs() << sucMsg("\t EXPECTED-FAILURE :") << funName << " check getId() << ", cs id:" << (getSrcCSID(source))->valueOnlyToString() << "> at (" << cs->getSourceLoc() << ")\n"; } else { + if (Options::ReadFromDB()) + { + SVFUtil::errs() << errMsg("\t UNEXPECTED FAILURE :") << funName <<"\n"; + assert(false && "test case failed!"); + return; + } SVFUtil::errs() << errMsg("\t UNEXPECTED FAILURE :") << funName << " check getId() << ", cs id:" << (getSrcCSID(source))->valueOnlyToString() << "> at (" From 774f148bbab30e7895069ee57679c4202ea94a52 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 27 Oct 2025 08:25:15 +1100 Subject: [PATCH 15/19] update --- svf-llvm/lib/SVFIRBuilder.cpp | 19 +------------------ 1 file changed, 1 insertion(+), 18 deletions(-) diff --git a/svf-llvm/lib/SVFIRBuilder.cpp b/svf-llvm/lib/SVFIRBuilder.cpp index 2e6168ffa..cc19f223a 100644 --- a/svf-llvm/lib/SVFIRBuilder.cpp +++ b/svf-llvm/lib/SVFIRBuilder.cpp @@ -56,24 +56,7 @@ SVFIR* SVFIRBuilder::build() double startTime = SVFStat::getClk(true); DBOUT(DGENERAL, outs() << pasMsg("\t Building SVFIR ...\n")); - - if (Options::ReadFromDB()) - { - GraphDBClient::getInstance().readSVFTypesFromDB(dbConnection, "SVFType", pag); - GraphDBClient::getInstance().initialSVFPAGNodesFromDB(dbConnection, "PAG",pag); - GraphDBClient::getInstance().readBasicBlockGraphFromDB(dbConnection, "BasicBlockGraph"); - CHGraph* chg = GraphDBClient::getInstance().buildCHGraphFromDB(dbConnection, "CHG", pag); - pag->setCHG(chg); - ICFG* icfg = GraphDBClient::getInstance().buildICFGFromDB(dbConnection, "ICFG", pag); - pag->icfg = icfg; - CallGraph* callGraph = GraphDBClient::getInstance().buildCallGraphFromDB(dbConnection,"CallGraph",pag); - pag->callGraph = callGraph; - GraphDBClient::getInstance().updatePAGNodesFromDB(dbConnection, "PAG", pag); - GraphDBClient::getInstance().loadSVFPAGEdgesFromDB(dbConnection, "PAG",pag); - GraphDBClient::getInstance().parseSVFStmtsForICFGNodeFromDBResult(pag); - return pag; - } - + // If the SVFIR has been built before, then we return the unique SVFIR of the program if(pag->getNodeNumAfterPAGBuild() > 1) return pag; From 7cca8abba00f6cb8e12f31aaac1318a2cb1ee938 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 27 Oct 2025 08:32:44 +1100 Subject: [PATCH 16/19] update saber --- svf-llvm/tools/SABER/saber.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/svf-llvm/tools/SABER/saber.cpp b/svf-llvm/tools/SABER/saber.cpp index a0d1f5c2e..86c1a2fd5 100644 --- a/svf-llvm/tools/SABER/saber.cpp +++ b/svf-llvm/tools/SABER/saber.cpp @@ -52,6 +52,7 @@ int main(int argc, char ** argv) if (Options::ReadFromDB()) { + pag = builder.build(); pag->setPagFromTXT("ReadFromDB"); } else @@ -62,8 +63,8 @@ int main(int argc, char ** argv) } LLVMModuleSet::buildSVFModule(moduleNameVec); + pag = builder.build(); } - pag = builder.build(); std::unique_ptr saber; From 2291cdfe876b5483b52e9b0768046e1087d8dfe3 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Mon, 27 Oct 2025 17:51:50 +1100 Subject: [PATCH 17/19] update lib --- svf/include/Graphs/ICFGNode.h | 4 ++-- svf/include/SVFIR/SVFType.h | 1 + svf/include/SVFIR/SVFVariables.h | 4 ++++ 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/svf/include/Graphs/ICFGNode.h b/svf/include/Graphs/ICFGNode.h index b59b87d9d..53f20a3c9 100644 --- a/svf/include/Graphs/ICFGNode.h +++ b/svf/include/Graphs/ICFGNode.h @@ -370,8 +370,8 @@ class FunExitICFGNode : public InterICFGNode friend class GraphDBClient; protected: - FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* b, SVFVar* formalRet) - : InterICFGNode(id, FunExitBlock), formalRet(formalRet) + FunExitICFGNode(NodeID id, const FunObjVar* f, SVFBasicBlock* b) + : InterICFGNode(id, FunExitBlock), formalRet(nullptr) { this->fun = f; this->bb = b; diff --git a/svf/include/SVFIR/SVFType.h b/svf/include/SVFIR/SVFType.h index 6346d3b2f..3970e7031 100644 --- a/svf/include/SVFIR/SVFType.h +++ b/svf/include/SVFIR/SVFType.h @@ -381,6 +381,7 @@ class SVFIntegerType : public SVFType class SVFFunctionType : public SVFType { + friend class GraphDBClient; private: const SVFType* retTy; std::vector params; diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index 16bf1a3ff..f1cc6d40a 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -2208,6 +2208,10 @@ class VarArgValPN : public ValVar protected: /// Constructor to create empty VarArgValPN (for GraphDBClient) VarArgValPN(NodeID i, const SVFType* type, PNODEK ty = VarargValNode) : ValVar(i, type, VarargValNode) {} + inline void setCallGraphNode(const FunObjVar* node) + { + callGraphNode = node; + } private: const FunObjVar* callGraphNode; From 25fb333faae9907bcc25935af411c344e777f685 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Tue, 28 Oct 2025 19:03:29 +1100 Subject: [PATCH 18/19] change baseObj return type --- svf/include/SVFIR/SVFVariables.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index f1cc6d40a..fe035efa0 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -676,7 +676,7 @@ class BaseObjVar : public ObjVar /// Get obj type const SVFType* getType() const { - return typeInfo->getType(); + return type; } /// Get the number of elements of this object From bb1652a3838e6dea4a5ec1fea004870cd57155d8 Mon Sep 17 00:00:00 2001 From: JasonZhongZexin Date: Tue, 28 Oct 2025 19:29:47 +1100 Subject: [PATCH 19/19] update --- svf/include/SVFIR/SVFVariables.h | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/svf/include/SVFIR/SVFVariables.h b/svf/include/SVFIR/SVFVariables.h index fe035efa0..c60646f48 100644 --- a/svf/include/SVFIR/SVFVariables.h +++ b/svf/include/SVFIR/SVFVariables.h @@ -675,6 +675,11 @@ class BaseObjVar : public ObjVar /// Get obj type const SVFType* getType() const + { + return typeInfo->getType(); + } + + const SVFType* getVarType() const { return type; }