finally check the version

Author: bjjwwang

.github/workflows/build.yml

@@ -39,8 +39,15 @@ jobs:
  - name: env-setup
  run: |
  npm install svf-lib
+
+ # set python version
+ - name: Set up Python 3.10
+ uses: actions/setup-python@v4
+ with:
+ python-version: '3.10'
+
  # set SVF_DIR, LLVM_DIR and Z3_DIR and build
- - name: build
+ - name: build and ctest
  run: |
  export SVF_DIR=$(npm root)/SVF
  export LLVM_DIR=$(npm root)/llvm-16.0.0.obj
@@ -50,3 +57,21 @@ jobs:
  echo "Z3_DIR="$Z3_DIR
  cmake .
  make
+ ctest -V
+
+ - name: Install Python dependencies
+ run: |
+ pip install --upgrade pip
+ pip install wheel pybind11 notebook nbconvert nbclient ipykernel build z3-solver
+ pip install pysvf -i https://test.pypi.org/simple/
+
+ - name: Register Jupyter kernel
+ run: |
+ python -m ipykernel install --user --name python3
+
+ - name: Run all notebooks in current directory
+ run: |
+ for nb in $(find . -maxdepth 2 -name "*-Solution.ipynb") ; do
+ echo "Executing $nb..."
+ jupyter nbconvert --to notebook --execute "$nb" --stdout > /dev/null
+ done

Assignment-1/CPP/Assignment-1.cpp

@@ -44,16 +44,96 @@ using namespace std;
 /// You will need to collect each path from src to snk and then add the path to the `paths` set.
 /// Add each path (a sequence of node IDs) as a string into std::set<std::string> paths
 /// in the format "START->1->2->4->5->END", where -> indicate an ICFGEdge connects two ICFGNode IDs
-void ICFGTraversal::reachability(const ICFGNode* curNode, const ICFGNode* snk) {
-/// TODO: your code starts from here
+void ICFGTraversal::reachability(const ICFGNode* src, const ICFGNode* dst) {
+const std::pair<const ICFGNode *, CallStack> curItem = std::make_pair(
+ src, callstack);
+if (visited.count(curItem)) return;
+visited.insert(curItem);
+path.push_back(src->getId());
+
+if (src == dst) {
+std::string singlePath = "START->";
+for (unsigned node : path)
+{
+singlePath.append(std::to_string(node));
+singlePath.append("->");
+}
+singlePath += "END";
+paths.insert(singlePath);
+}
+for (const ICFGEdge *edge: src->getOutEdges()) {
+if (edge->isIntraCFGEdge()) {
+reachability(edge->getDstNode(), dst);
+} else if (const CallCFGEdge *callEdge = SVFUtil::dyn_cast<CallCFGEdge>(edge)) {
+callstack.push_back(callEdge->getSrcNode());
+reachability(edge->getDstNode(), dst);
+callstack.pop_back();
+} else if (const RetICFGNode *retNode = SVFUtil::dyn_cast<RetICFGNode>(edge->getDstNode())) {
+if (!callstack.empty() && (callstack.back() == retNode->getCallICFGNode())) {
+callstack.pop_back();
+reachability(edge->getDstNode(), dst);
+callstack.push_back(retNode->getCallICFGNode());
+} else if (callstack.empty()) {
+reachability(edge->getDstNode(), dst);
+}
+}
+}
+path.pop_back();
+visited.erase(curItem);
+}
+
+
+// Helper function to extract data enclosed in braces
+string extractDataFromBraces(const string &str) {
+int leftBrace = str.find("{") + 1;
+int rightBrace = str.find("}", leftBrace);
+return str.substr(leftBrace, rightBrace - leftBrace);
 }
 
 /// TODO: Implement your code to parse the two lines to identify sources and sinks from `SrcSnk.txt` for your
-/// reachability analysis The format in SrcSnk.txt is in the form of 
-/// line 1 for sources "{ api1 api2 api3 }" 
+/// reachability analysis The format in SrcSnk.txt is in the form of
+/// line 1 for sources "{ api1 api2 api3 }"
 /// line 2 for sinks "{ api1 api2 api3 }"
 void ICFGTraversal::readSrcSnkFromFile(const string& filename) {
-/// TODO: your code starts from here
+// Open the file
+ifstream fileHandler(filename);
+
+// Check if the file is successfully opened
+if (!fileHandler.is_open()) {
+cerr << "Error opening file: " << filename << endl;
+return;
+}
+
+string temp, sourcesLine, sinksLine;
+bool isSourceLine = true;
+
+// Read the file line by line
+while (getline(fileHandler, temp)) {
+// Alternate between reading source and sink lines
+if (isSourceLine) {
+sourcesLine = temp;
+} else {
+sinksLine = temp;
+}
+isSourceLine = !isSourceLine;
+}
+
+// Extract and process sources and sinks
+string sources = extractDataFromBraces(sourcesLine);
+string sinks = extractDataFromBraces(sinksLine);
+
+// Parse and insert source APIs into the set
+stringstream sourcesStream(sources);
+while (sourcesStream >> temp) {
+checker_source_api.insert(temp);
+}
+
+// Parse and insert sink APIs into the set
+stringstream sinksStream(sinks);
+while (sinksStream >> temp) {
+checker_sink_api.insert(temp);
+}
+
 }
 
 // TODO: Implement your Andersen's Algorithm here
@@ -65,15 +145,75 @@ void ICFGTraversal::readSrcSnkFromFile(const string& filename) {
 /// q <--GEP, fld-- p => for each o ∈ pts(p) : pts(q) = pts(q) ∪ {o.fld}
 /// pts(q) denotes the points-to set of q
 void AndersenPTA::solveWorklist() {
-/// TODO: your code starts from here
+for (ConstraintGraph::const_iterator nodeIt = consCG->begin(), nodeEit = consCG->end();
+ nodeIt != nodeEit; nodeIt++) {
+ConstraintNode *cgNode = nodeIt->second;
+for (ConstraintEdge *edge: cgNode->getAddrInEdges()) {
+const AddrCGEdge *addr = SVFUtil::cast<AddrCGEdge>(edge);
+NodeID dst = addr->getDstID();
+NodeID src = addr->getSrcID();
+if (addPts(dst, src))
+pushIntoWorklist(dst);
+}
+}
+
+// Keep solving until workList is empty.
+while (!isWorklistEmpty()) {
+NodeID nodeId = popFromWorklist();
+ConstraintNode *node = consCG->getConstraintNode(nodeId);
+
+/// foreach o \in pts(p)
+for (NodeID o: getPts(nodeId)) {
+
+/// *p = q pts(q) \subseteq pts(o)
+for (ConstraintEdge *edge: node->getStoreInEdges()) {
+if (addCopyEdge(edge->getSrcID(), o)) {
+pushIntoWorklist(edge->getSrcID());
+}
+}
+// r = *p pts(o) \subseteq pts(r)
+for (ConstraintEdge *edge: node->getLoadOutEdges()) {
+if (addCopyEdge(o, edge->getDstID())) {
+pushIntoWorklist(o);
+}
+}
+}
+
+/// q = p pts(p) \subseteq pts(q)
+for (ConstraintEdge *edge: node->getCopyOutEdges()) {
+if (unionPts(edge->getDstID(), edge->getSrcID())) {
+pushIntoWorklist(edge->getDstID());
+}
+}
+
+/// q = &p->f pts(p.f) \subseteq pts(q)
+for (ConstraintEdge *edge: node->getGepOutEdges()) {
+PointsTo fieldObjs;
+if(NormalGepCGEdge* gepEdge = SVFUtil::dyn_cast<NormalGepCGEdge>(edge))
+{
+for(NodeID o: getPts(edge->getSrcID()))
+{
+NodeID fld = consCG->getGepObjVar(o, gepEdge->getAccessPath().getConstantStructFldIdx());
+fieldObjs.set(fld);
+}
+}
+if (unionPts(edge->getDstID(), fieldObjs)) {
+pushIntoWorklist(edge->getDstID());
+}
+}
+}
 }
 
 /// TODO: Checking aliases of the two variables at source and sink. For example:
 /// src instruction: actualRet = source();
 /// snk instruction: sink(actualParm,...);
 /// return true if actualRet is aliased with any parameter at the snk node (e.g., via ander->alias(..,..))
 bool ICFGTraversal::aliasCheck(const CallICFGNode* src, const CallICFGNode* snk) {
-/// TODO: your code starts from here
+for (const SVFVar *node: snk->getActualParms()) {
+if (ander->alias(src->getRetICFGNode()->getActualRet()->getId(), node->getId())) {
+return true;
+}
+}
 return false;
 }
 

Assignment-1/CPP/test.cpp

@@ -7,6 +7,14 @@
 #include "Util/Options.h"
 
 using namespace std;
+void checkICFGcase(std::string moduleName, const std::set<std::string>& res, const std::set<std::string>& expected) {
+std::stringstream ss;
+ss << "\n wrong paths generated - " << moduleName << " failed !";
+assert(res.size() == expected.size() && ss.str().c_str());
+for (auto path : res) {
+assert(expected.find(path) != expected.end() && ss.str().c_str());
+}
+}
 
 void TestICFG(std::vector<std::string>& moduleNameVec) {
 LLVMModuleSet::getLLVMModuleSet()->buildSVFModule(moduleNameVec);
@@ -17,26 +25,76 @@ void TestICFG(std::vector<std::string>& moduleNameVec) {
 ICFG* icfg = pag->getICFG();
 // If you want to test your own case, please change the dump name
 ICFGTraversal* gt = new ICFGTraversal(pag);
-const fs::path& config = CUR_DIR() / "../SrcSnk.txt";
+const fs::path& config = CUR_DIR() / "../Tests/SrcSnk.txt";
 gt->readSrcSnkFromFile(config);
 for (const CallICFGNode* src : gt->identifySources()) {
 for (const CallICFGNode* snk : gt->identifySinks()) {
 gt->reachability(src, snk);
 }
 }
 std::string moduleName = moduleNameVec[0].substr(moduleNameVec[0].find_last_of('/') + 1);
+
 if (moduleName == "test1.ll") {
-std::set<std::string> expected = {"START->6->7->8->9->10->1->5->2->11->14->END",
- "START->6->7->8->9->12->1->5->2->13->16->END"};
+std::set<std::string> expected = {"START->3->4->5->END"};
 assert(gt->getPaths() == expected && " \n wrong paths generated - test1 failed !");
+checkICFGcase(moduleName, gt->getPaths(), expected);
 }
 else if (moduleName == "test2.ll") {
+std::set<std::string> expected = {"START->3->4->5->6->7->8->9->END",
+ "START->3->4->5->6->7->END", "START->5->6->7->8->9->END",
+ "START->5->6->7->END"};
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test3.ll") {
+std::set<std::string> expected = {"START->6->7->8->1->5->2->9->10->END"};
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test4.ll") {
+std::set<std::string> expected = {"START->12->13->14->3->8->9->1->7->2->10->11->4->15->16->END"};
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test5.ll") {
+std::set<std::string> expected =
+ {
+ "START->6->7->8->9->10->1->5->2->11->14->END",
+ "START->6->7->8->9->12->1->5->2->13->16->END",
+ };
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test6.ll") {
+std::set<std::string> expected =
+ {
+ "START->12->13->14->15->16->3->8->9->1->7->2->10->11->4->17->20->END",
+ "START->12->13->14->15->18->3->8->9->1->7->2->10->11->4->19->22->END",
+ };
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test7.ll") {
+//START->16->1->2->END
 std::set<std::string> expected = {"START->17->1->7->END"};
-assert(gt->getPaths().size() == expected.size() && " \n wrong paths generated - test2 failed !");
-for (auto path : gt->getPaths()) {
-assert(expected.find(path) != expected.end() && " \n wrong paths generated - test2 failed !");
-}
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test8.ll") {
+std::set<std::string> expected =
+ {
+ "START->6->7->8->9->10->1->5->2->11->14->END",
+ "START->6->7->8->9->12->1->5->2->13->16->END",
+ };
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+else if (moduleName == "test9.ll") {
+std::set<std::string> expected = {"START->7->8->9->10->11->14->END"};
+checkICFGcase(moduleName, gt->getPaths(), expected);
 }
+else if (moduleName == "test10.ll") {
+std::set<std::string> expected =
+ {
+ "START->3->4->5->6->7->9->11->END",
+ "START->3->4->5->6->8->10->14->17->END",
+ };
+checkICFGcase(moduleName, gt->getPaths(), expected);
+}
+
 
 for (auto path : gt->getPaths())
 std::cerr << path << "\n";
@@ -107,13 +165,13 @@ void TestTaint(std::vector<std::string>& moduleNameVec) {
 std::string moduleName = moduleNameVec[0].substr(moduleNameVec[0].find_last_of('/') + 1);
 if (moduleName == "test1.ll") {
 set<string> expected = {"START->6->1->5->2->7->8->9->10->END"};
-assert(taint->getPaths() == expected && " \n Wrong paths generated - Test1 failed !");
-cout << "\n Test1 passed !" << endl;
+assert(taint->getPaths() == expected && " \n wrong paths generated - test1 failed !");
+cout << "\n test1 passed !" << endl;
 }
-else if (moduleName == "test2.ll") {
+else if (moduleName == "test4.ll") {
 set<string> expected = {"START->6->1->5->2->7->8->9->10->11->13->14->END"};
-assert(taint->getPaths() == expected && " \n Wrong paths generated - Test4 failed !");
-cout << "\n Test2 passed !" << endl;
+assert(taint->getPaths() == expected && " \n wrong paths generated - test4 failed !");
+cout << "\n test2 passed !" << endl;
 }
 SVF::SVFIR::releaseSVFIR();
 SVF::LLVMModuleSet::releaseLLVMModuleSet();