refactoring

Author: jsinglet

cpp/common/src/codingstandards/cpp/Concurrency.qll

@@ -421,8 +421,12 @@ class LockProtectedControlFlowNode extends ThreadedCFN {
 /**
  * Models a function that conditionally waits.
  */
-class ConditionalWait extends FunctionCall {
-  ConditionalWait() {
+abstract class ConditionalWait extends FunctionCall {}
+/**
+ * Models a function in CPP that will conditionally wait. 
+ */
+class CPPConditionalWait extends ConditionalWait {
+  CPPConditionalWait() {
     exists(MemberFunction mf |
       mf = getTarget() and
       mf.getDeclaringType().hasQualifiedName("std", "condition_variable") and
@@ -431,6 +435,15 @@ class ConditionalWait extends FunctionCall {
   }
 }
 
+/**
+ * Models a function in C that will conditionally wait. 
+ */
+class CConditionalWait extends ConditionalWait {
+  CConditionalWait() {
+    getTarget().getName() in ["cnd_wait"]
+  }
+}
+
 /**
  * Models a call to a `std::thread` constructor that depends on a mutex.
  */

cpp/common/src/codingstandards/cpp/rules/wrapspuriousfunctioninloop/WrapSpuriousFunctionInLoop.qll

@@ -0,0 +1,19 @@
+/**
+ * Provides a library which includes a `problems` predicate for reporting
+ * functions that should be wrapped in a loop because they may wake up spuriously.
+ */
+
+import cpp
+import codingstandards.cpp.Customizations
+import codingstandards.cpp.Exclusions
+import codingstandards.cpp.Concurrency
+
+abstract class WrapSpuriousFunctionInLoopSharedQuery extends Query { }
+
+Query getQuery() { result instanceof WrapSpuriousFunctionInLoopSharedQuery }
+
+query predicate problems(ConditionalWait cw, string message) {
+  not isExcluded(cw, getQuery()) and
+  not cw.getEnclosingStmt().getParentStmt*() instanceof Loop and
+  message = "Use of a function that may wake up spuriously without a controlling loop."
+}

cpp/common/test/rules/wrapspuriousfunctioninloop/WrapSpuriousFunctionInLoop.expected

@@ -0,0 +1,3 @@
+| test.cpp:11:8:11:11 | call to wait | Use of a function that may wake up spuriously without a controlling loop. |
+| test.cpp:49:6:49:9 | call to wait | Use of a function that may wake up spuriously without a controlling loop. |
+| test.cpp:59:8:59:11 | call to wait | Use of a function that may wake up spuriously without a controlling loop. |

cpp/common/test/rules/wrapspuriousfunctioninloop/WrapSpuriousFunctionInLoop.ql

@@ -0,0 +1,2 @@
+// GENERATED FILE - DO NOT MODIFY
+import codingstandards.cpp.rules.wrapspuriousfunctioninloop.WrapSpuriousFunctionInLoop

cpp/common/test/rules/wrapspuriousfunctioninloop/test.cpp

@@ -0,0 +1,62 @@
+#include <condition_variable>
+#include <mutex>
+
+static std::mutex mu;
+static std::condition_variable cv;
+
+void f1() {
+  std::unique_lock<std::mutex> lk(mu);
+
+  if (1) {
+    cv.wait(lk); // NON_COMPLIANT
+  }
+}
+
+void f2() {
+  std::unique_lock<std::mutex> lk(mu);
+  int i = 2;
+  while (i > 0) {
+    cv.wait(lk); // COMPLIANT
+    i--;
+  }
+}
+
+void f3() {
+  std::unique_lock<std::mutex> lk(mu);
+  int i = 2;
+  do {
+    cv.wait(lk); // COMPLIANT
+    i--;
+  } while (i > 0);
+}
+
+void f4() {
+  std::unique_lock<std::mutex> lk(mu);
+
+  for (;;) {
+    cv.wait(lk); // COMPLIANT
+  }
+}
+
+void f5() {
+  std::unique_lock<std::mutex> lk(mu);
+
+  int i = 2;
+  while (i > 0) {
+    i--;
+  }
+
+  cv.wait(lk); // NON_COMPLIANT
+}
+
+void f6() {
+  std::unique_lock<std::mutex> lk(mu);
+
+  for (int i = 0; i < 10; i++) {
+  }
+  int i = 0;
+  if (i > 0) {
+    cv.wait(lk); // NON_COMPLIANT
+    i--;
+  }
+}