[clang-tidy] Add spuriously-wake-up-functions check

[abelkocsis]

Summary

According to
https://wiki.sei.cmu.edu/confluence/display/cplusplus/CON54-CPP.+Wrap+functions+that+can+spuriously+wake+up+in+a+loop
and
https://wiki.sei.cmu.edu/confluence/display/c/CON36-C.+Wrap+functions+that+can+spuriously+wake+up+in+a+loop
misc-spuriously-wake-up-functions check is created. The check finds
cnd_wait or wait function calls in an IfStmt and warns the user to
replace it with a WhileStmt or use it with a lambda parameter.

[Eugene.Zelenko]

I don't think that misc module should be used when checks belong to cert

clang-tools-extra/clang-tidy/misc/SpuriouslyWakeUpFunctionsCheck.cpp

77 ↗

(On Diff #231616)

Unnecessary empty line.

clang-tools-extra/docs/ReleaseNotes.rst

70

Please move into aliases section (in alphabetical order). Same below.

163

Please use alphabetical order.

166

Please synchronize with first statement in documentation.

clang-tools-extra/test/clang-tidy/misc-spuriously-wake-up-functions.cpp

1 ↗

(On Diff #231616)

What will happen if libcxx is not part build/source tree?

[aaron.ballman]

clang-tools-extra/clang-tidy/misc/MiscTidyModule.cpp

45–46 ↗

(On Diff #231616)

If we want to expose this check outside of the CERT module, I think it should go into bugprone rather than misc.

clang-tools-extra/clang-tidy/misc/SpuriouslyWakeUpFunctionsCheck.cpp

62 ↗

(On Diff #231616)

What about cnd_timedwait?

clang-tools-extra/clang-tidy/misc/SpuriouslyWakeUpFunctionsCheck.h

19 ↗

(On Diff #231616)

WhileStm -> WhileStmt

clang-tools-extra/test/clang-tidy/misc-spuriously-wake-up-functions.cpp

1 ↗

(On Diff #231616)

Also, there are no tests for the C functionality yet.

[abelkocsis]

Checker is moved to bugprone section, tests added. C checker is improved, and documentations are synchronised.

[Eugene.Zelenko]

clang-tools-extra/docs/clang-tidy/checks/bugprone-spuriously-wake-up-functions.rst

5

Please make length same as in title.

[abelkocsis]

Adding matcher for cnd_timedwait and test cases.
Small fix in documentation

[whisperity]

The checks.rst has recently been updated to show "normal" (main entry) checks and "aliases" in different tables in D36051. Please register the alias-ness accordingly.

[abelkocsis]

docs/clang-tidy/checks/lsit.rst update

[sylvestre.ledru]

clang-tools-extra/docs/clang-tidy/checks/list.rst

12

Could you try to evaluate the severity? :)
thanks

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.cpp

23

These should all use ::std::whatever to guard against pathological code that uses std inside of another namespace.

81

This should be simplified into:

const auto *MatchedWait = Result.Nodes.getNodeAs<CallExpr>("wait");
StringRef WaitName = MatchedWait->getDirectCallee()->getName();
diag(MatchedWait->getExprLoc(), "'%0' should be placed inside a while statement %select{|or used with a conditional parameter}1") << WaitName << (WaitName != "cnd_wait" && WaitName != cnd_timedwait);

clang-tools-extra/docs/clang-tidy/checks/bugprone-spuriously-wake-up-functions.rst

7

Missing cnd_timedwait

clang-tools-extra/test/clang-tidy/Inputs/bugprone-spuriously-wake-up-functions/chrono.h

49 ↗

(On Diff #235232)

Please add a newline to the end of the file.

clang-tools-extra/test/clang-tidy/Inputs/bugprone-spuriously-wake-up-functions/condition_variable.h

41 ↗

(On Diff #235232)

Please add a newline to the end of the file.

clang-tools-extra/test/clang-tidy/Inputs/bugprone-spuriously-wake-up-functions/cstdint.h

4 ↗

(On Diff #235232)

Please add a newline to the end of the file.

clang-tools-extra/test/clang-tidy/Inputs/bugprone-spuriously-wake-up-functions/mutex.h

20 ↗

(On Diff #235232)

Please add a newline to the end of the file.

clang-tools-extra/test/clang-tidy/Inputs/bugprone-spuriously-wake-up-functions/ratio.h

29 ↗

(On Diff #235232)

Please add a newline to the end of the file.

clang-tools-extra/test/clang-tidy/bugprone-spuriously-wake-up-functions.cpp

2 ↗

(On Diff #235232)

Are you planning to use these declarations in multiple test files? If not, then we typically put all of the header code into the test file rather than added as explicit files.

99 ↗

(On Diff #235232)

You are missing test cases that use other kinds of loops, like a do..while or for loop.

[abelkocsis]

clang-tools-extra/test/clang-tidy/bugprone-spuriously-wake-up-functions.cpp

2 ↗

(On Diff #235232)

I'm not sure yet, so I move it into the test file.

[abelkocsis]

Checker fixes, updates test file adding test cases for doWhile and for statements, test headers deleted.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.cpp

61

Sorry for not noticing this earlier, but I think you can make two calls to addMatcher(), one for the C check and one for the C++ check. Then you can register only the matcher needed for the language mode you are currently in. e.g.,

if (getLangOpts().CPlusPlus)
  // Check for CON54-CPP
else
  // Check for CON36-C

This should make the check slightly more efficient because of the mutually exclusive nature of these APIs without changing the behavior.

clang-tools-extra/docs/clang-tidy/checks/list.rst

12

Given that these are essentially CERT rules, I'd go with the CERT severity for them -- however, I say that only because I'm not certain what approach is supposed to be taken for these severity markings.

CERT marks these two rules as having a low severity, FWIW.

[abelkocsis]

Checker update to analyse language, separated checks for C and C++.

[steakhal]

clang-tools-extra/docs/clang-tidy/checks/list.rst

304–305

In case the checker does not offer automatic fixes, remove "Yes" from the given table entries.

[abelkocsis]

docs/list.rst update

[aaron.ballman]

LGTM aside from a test coverage request.

clang-tools-extra/test/clang-tidy/bugprone-spuriously-wake-up-functions.c

26–30 ↗

(On Diff #244098)

Can you add a test case to demonstrate the behavior when there's not a compound statement involved? And another one for a slightly more complex if predicate? e.g.,

if (list_c.next == NULL)
  if (0 != cnd_wait(&condition_c, &lock))
    ;

if (list_c.next == NULL && 0 != cnd_wait(&condition_c, &lock))
  ;

Both of these should be flagged similar to the form with the compound statement.

[abelkocsis]

Test cases adding, checker modifying to pass new cases.

[aaron.ballman]

LGTM, do you need me to commit on your behalf?

clang-tools-extra/test/clang-tidy/bugprone-spuriously-wake-up-functions.c

165 ↗

(On Diff #245113)

Please add a newline to the end of the file.

[abelkocsis]

Format fix

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

 #include "MultipleStatementMacroCheck.h"
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
 #include "ReservedIdentifierCheck.h"
 #include "SignedCharMisuseCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
+#include "SpuriouslyWakeUpFunctionsCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousIncludeCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
 #include "SuspiciousSemicolonCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<ReservedIdentifierCheck>(
         "bugprone-reserved-identifier");
     CheckFactories.registerCheck<SignedCharMisuseCheck>(
         "bugprone-signed-char-misuse");
     CheckFactories.registerCheck<SizeofContainerCheck>(
         "bugprone-sizeof-container");
     CheckFactories.registerCheck<SizeofExpressionCheck>(
         "bugprone-sizeof-expression");
+    CheckFactories.registerCheck<SpuriouslyWakeUpFunctionsCheck>(
+        "bugprone-spuriously-wake-up-functions");
     CheckFactories.registerCheck<StringConstructorCheck>(
         "bugprone-string-constructor");
     CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
         "bugprone-string-integer-assignment");
     CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
         "bugprone-string-literal-with-embedded-nul");
     CheckFactories.registerCheck<SuspiciousEnumUsageCheck>(
         "bugprone-suspicious-enum-usage");

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

add_clang_library(clangTidyBugproneModule
   MultipleStatementMacroCheck.cpp
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
   ReservedIdentifierCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
+  SpuriouslyWakeUpFunctionsCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousIncludeCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
   SuspiciousMissingCommaCheck.cpp
   SuspiciousSemicolonCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.h

+//===--- SpuriouslyWakeUpFunctionsCheck.h - clang-tidy ----------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or 
+/// ``wait_until`` function calls when the function is not invoked from a loop 
+/// that checks whether a condition predicate holds or the function has a 
+/// condition parameter.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-spuriously-wake-up-functions.html
+class SpuriouslyWakeUpFunctionsCheck : public ClangTidyCheck {
+public:
+  SpuriouslyWakeUpFunctionsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SPURIOUSLYWAKEUPFUNCTIONSCHECK_H

clang-tools-extra/clang-tidy/bugprone/SpuriouslyWakeUpFunctionsCheck.cpp

+//===--- SpuriouslyWakeUpFunctionsCheck.cpp - clang-tidy ------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "SpuriouslyWakeUpFunctionsCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+void SpuriouslyWakeUpFunctionsCheck::registerMatchers(MatchFinder *Finder) {
+
+  auto hasUniqueLock = hasDescendant(declRefExpr(
+      hasDeclaration(varDecl(hasType(recordDecl(classTemplateSpecializationDecl(
+          hasName("::std::unique_lock"),
+          hasTemplateArgument(
+              0, templateArgument(refersToType(qualType(hasDeclaration(
+                     cxxRecordDecl(hasName("::std::mutex"))))))))))))));
+
+  auto hasWaitDescendantCPP = hasDescendant(
+      cxxMemberCallExpr(
+          anyOf(
+              allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
+                        allOf(hasName("::std::condition_variable::wait"),
+                              parameterCountIs(1)))))),
+                    onImplicitObjectArgument(
+                        declRefExpr(to(varDecl(hasType(references(recordDecl(
+                            hasName("::std::condition_variable")))))))),
+                    hasUniqueLock),
+              allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
+                        allOf(hasName("::std::condition_variable::wait_for"),
+                              parameterCountIs(2)))))),
+                    onImplicitObjectArgument(
+                        declRefExpr(to(varDecl(hasType(references(recordDecl(
+                            hasName("::std::condition_variable")))))))),
+                    hasUniqueLock),
+              allOf(hasDescendant(memberExpr(hasDeclaration(functionDecl(
+                        allOf(hasName("::std::condition_variable::wait_until"),
+                              parameterCountIs(2)))))),
+                    onImplicitObjectArgument(
+                        declRefExpr(to(varDecl(hasType(references(recordDecl(
+                            hasName("::std::condition_variable")))))))),
+                    hasUniqueLock)
+
+                  ))
+          .bind("wait"));
+
+  auto hasWaitDescendantC = hasDescendant(
+      callExpr(callee(functionDecl(
+                   anyOf(hasName("cnd_wait"), hasName("cnd_timedwait")))))
+          .bind("wait"));
+  if (getLangOpts().CPlusPlus) {
+    // Check for `CON54-CPP`
+    Finder->addMatcher(
+        ifStmt(
+
+            allOf(hasWaitDescendantCPP,
+                  unless(anyOf(hasDescendant(ifStmt(hasWaitDescendantCPP)),
+                               hasDescendant(whileStmt(hasWaitDescendantCPP)),
+                               hasDescendant(forStmt(hasWaitDescendantCPP)),
+                               hasDescendant(doStmt(hasWaitDescendantCPP)))))
+
+                ),
+        this);
+  } else {
+    // Check for `CON36-C`
+    Finder->addMatcher(
+
+        ifStmt(
+            allOf(hasWaitDescendantC,
+                  unless(anyOf(hasDescendant(ifStmt(hasWaitDescendantC)),
+                               hasDescendant(whileStmt(hasWaitDescendantC)),
+                               hasDescendant(forStmt(hasWaitDescendantC)),
+                               hasDescendant(doStmt(hasWaitDescendantC)),
+                               hasParent(whileStmt()),
+                               hasParent(compoundStmt(hasParent(whileStmt()))),
+                               hasParent(forStmt()),
+                               hasParent(compoundStmt(hasParent(forStmt()))),
+                               hasParent(doStmt()),
+                               hasParent(compoundStmt(hasParent(doStmt())))))
+
+                      ))
+
+            ,
+        this);
+  }
+}
+
+void SpuriouslyWakeUpFunctionsCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *MatchedWait = Result.Nodes.getNodeAs<CallExpr>("wait");
+  StringRef WaitName = MatchedWait->getDirectCallee()->getName();
+  diag(MatchedWait->getExprLoc(),
+       "'%0' should be placed inside a while statement %select{|or used with a "
+       "conditional parameter}1")
+      << WaitName << (WaitName != "cnd_wait" && WaitName != "cnd_timedwait");
+}
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

 //===--- CERTTidyModule.cpp - clang-tidy ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "../bugprone/BadSignalToKillThreadCheck.h"
 #include "../bugprone/ReservedIdentifierCheck.h"
+#include "../bugprone/SpuriouslyWakeUpFunctionsCheck.h"
 #include "../bugprone/UnhandledSelfAssignmentCheck.h"
 #include "../google/UnnamedNamespaceInHeaderCheck.h"
 #include "../misc/NewDeleteOverloadsCheck.h"
 #include "../misc/NonCopyableObjects.h"
 #include "../misc/StaticAssertCheck.h"
 #include "../misc/ThrowByValueCatchByReferenceCheck.h"
 #include "../performance/MoveConstructorInitCheck.h"
 #include "../readability/UppercaseLiteralSuffixCheck.h"

 namespace clang {
 namespace tidy {
 namespace cert {
 
 class CERTModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
+    // CON
+    CheckFactories.registerCheck<bugprone::SpuriouslyWakeUpFunctionsCheck>(
+        "cert-con54-cpp");
     // DCL
     CheckFactories.registerCheck<PostfixOperatorCheck>(
         "cert-dcl21-cpp");
     CheckFactories.registerCheck<VariadicFunctionDefCheck>("cert-dcl50-cpp");
     CheckFactories.registerCheck<bugprone::ReservedIdentifierCheck>(
         "cert-dcl51-cpp");
     CheckFactories.registerCheck<misc::NewDeleteOverloadsCheck>(
         "cert-dcl54-cpp");
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<bugprone::UnhandledSelfAssignmentCheck>(
         "cert-oop54-cpp");
     CheckFactories.registerCheck<NonTrivialTypesLibcMemoryCallsCheck>(
         "cert-oop57-cpp");
     CheckFactories.registerCheck<MutatingCopyCheck>(
         "cert-oop58-cpp");
 
     // C checkers
+    // CON
+    CheckFactories.registerCheck<bugprone::SpuriouslyWakeUpFunctionsCheck>(
+        "cert-con36-c");
     // DCL
     CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
     CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
         "cert-dcl16-c");
     CheckFactories.registerCheck<bugprone::ReservedIdentifierCheck>(
         "cert-dcl37-c");
     // ENV
     CheckFactories.registerCheck<CommandProcessorCheck>("cert-env33-c");

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
 New module
 ^^^^^^^^^^
 - New module `llvmlibc`.
 
   This module contains checks related to the LLVM-libc coding standards.
 
 New checks
 ^^^^^^^^^^
 - New :doc:`cppcoreguidelines-avoid-non-const-global-variables
   <clang-tidy/checks/cppcoreguidelines-avoid-non-const-global-variables>` check.
   Finds non-const global variables as described in check I.2 of C++ Core
   Guidelines.
 
 - New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   <clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.
 
   Finds cases where an integer expression is added to or subtracted from the
   result of a memory allocation function (``malloc()``, ``calloc()``,
   ``realloc()``, ``alloca()``) instead of its argument.
 
+- New :doc:`bugprone-spuriously-wake-up-functions
+  <clang-tidy/checks/bugprone-spuriously-wake-up-functions>` check.
+
+  Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or
+  ``wait_until`` function calls when the function is not invoked from a loop
+  that checks whether a condition predicate holds or the function has a 
+  condition parameter.
+
 - New :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone-reserved-identifier>` check.
 
   Checks for usages of identifiers reserved for use by the implementation.
 
 - New :doc:`bugprone-suspicious-include
   <clang-tidy/checks/bugprone-suspicious-include>` check.
 

 - New :doc:`misc-no-recursion
   <clang-tidy/checks/misc-no-recursion>` check.
 
   Finds recursive functions and diagnoses them.
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
+- New alias :doc:`cert-con36-c
+  <clang-tidy/checks/cert-con36-c>` to
+  :doc:`bugprone-spuriously-wake-up-functions
+  <clang-tidy/checks/bugprone-spuriously-wake-up-functions>` was added.
+
+- New alias :doc:`cert-con54-cpp
+  <clang-tidy/checks/cert-con54-cpp>` to
+  :doc:`bugprone-spuriously-wake-up-functions
+  <clang-tidy/checks/bugprone-spuriously-wake-up-functions>` was added.
+
 - New alias :doc:`cert-dcl37-c
   <clang-tidy/checks/cert-dcl37-c>` to
   :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone-reserved-identifier>` was added.
 
 - New alias :doc:`cert-dcl51-cpp
   <clang-tidy/checks/cert-dcl51-cpp>` to
   :doc:`bugprone-reserved-identifier
   <clang-tidy/checks/bugprone-reserved-identifier>` was added.
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`readability-qualified-auto
   <clang-tidy/checks/readability-qualified-auto>` check now supports a 
   `AddConstToQualified` to enable adding ``const`` qualifiers to variables
   typed with ``auto *`` and ``auto &``.
 
 - Improved :doc:`readability-redundant-string-init
   <clang-tidy/checks/readability-redundant-string-init>` check now supports a
   `StringNames` option enabling its application to custom string classes. The
   check now detects in class initializers and constructor initializers which
   are deemed to be redundant.
 
 - Checks supporting the ``HeaderFileExtensions`` flag now support ``;`` as a
   delimiter in addition to ``,``, with the latter being deprecated as of this
   release. This simplifies how one specifies the options on the command line:
   ``--config="{CheckOptions: [{ key: HeaderFileExtensions, value: h;;hpp;hxx }]}"``
 
 Renamed checks

clang-tools-extra/docs/clang-tidy/checks/bugprone-spuriously-wake-up-functions.rst

+.. title:: clang-tidy - bugprone-spuriously-wake-up-functions
+
+bugprone-spuriously-wake-up-functions
+=====================================
+
+Finds ``cnd_wait``, ``cnd_timedwait``, ``wait``, ``wait_for``, or 
+``wait_until`` function calls when the function is not invoked from a loop
+that checks whether a condition predicate holds or the function has a 
+condition parameter.
+
+.. code-block: c++
+
+    if (condition_predicate) {
+        condition.wait(lk);
+    }
+
+.. code-block: c
+
+    if (condition_predicate) {
+        if (thrd_success != cnd_wait(&condition, &lock)) {
+        }
+    }
+
+This check corresponds to the CERT C++ Coding Standard rule
+`CON54-CPP. Wrap functions that can spuriously wake up in a loop
+<https://wiki.sei.cmu.edu/confluence/display/cplusplus/CON54-CPP.+Wrap+functions+that+can+spuriously+wake+up+in+a+loop>`_.
+and CERT C Coding Standard rule
+`CON36-C. Wrap functions that can spuriously wake up in a loop
+<https://wiki.sei.cmu.edu/confluence/display/c/CON36-C.+Wrap+functions+that+can+spuriously+wake+up+in+a+loop>`_.

clang-tools-extra/docs/clang-tidy/checks/cert-con36-c.rst

+.. title:: clang-tidy - cert-con36-c
+.. meta::
+:http-equiv=refresh: 5;URL=bugprone-spuriously-wake-up-functions.html
+  
+cert-con36-c
+============
+
+The cert-con36-c check is an alias, please see
+`bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_ 
+for more information.

clang-tools-extra/docs/clang-tidy/checks/cert-con54-cpp.rst

+.. title:: clang-tidy - cert-con54-cpp
+.. meta::
+:http-equiv=refresh: 5;URL=bugprone-spuriously-wake-up-functions.html
+  
+cert-con54-cpp
+==============
+
+The cert-con54-cpp check is an alias, please see
+`bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_ 
+for more information.

clang-tools-extra/docs/clang-tidy/checks/list.rst

 .. title:: clang-tidy - Clang-Tidy Checks
 
 Clang-Tidy Checks
 =================
 
 .. toctree::
    :glob:
    :hidden:
 
    *
 
 .. csv-table::
    :header: "Name", "Offers fixes"
 
    `abseil-duration-addition <abseil-duration-addition.html>`_, "Yes"
    `abseil-duration-comparison <abseil-duration-comparison.html>`_, "Yes"
    `abseil-duration-conversion-cast <abseil-duration-conversion-cast.html>`_, "Yes"
    `abseil-duration-division <abseil-duration-division.html>`_, "Yes"
    `abseil-duration-factory-float <abseil-duration-factory-float.html>`_, "Yes"
    `abseil-duration-factory-scale <abseil-duration-factory-scale.html>`_, "Yes"
.. csv-table::
    `bugprone-multiple-statement-macro <bugprone-multiple-statement-macro.html>`_,
    `bugprone-not-null-terminated-result <bugprone-not-null-terminated-result.html>`_, "Yes"
    `bugprone-parent-virtual-call <bugprone-parent-virtual-call.html>`_, "Yes"
    `bugprone-posix-return <bugprone-posix-return.html>`_, "Yes"
    `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_, "Yes"
    `bugprone-signed-char-misuse <bugprone-signed-char-misuse.html>`_,
    `bugprone-sizeof-container <bugprone-sizeof-container.html>`_,
    `bugprone-sizeof-expression <bugprone-sizeof-expression.html>`_,
+   `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
    `bugprone-string-constructor <bugprone-string-constructor.html>`_, "Yes"
    `bugprone-string-integer-assignment <bugprone-string-integer-assignment.html>`_, "Yes"
    `bugprone-string-literal-with-embedded-nul <bugprone-string-literal-with-embedded-nul.html>`_,
    `bugprone-suspicious-enum-usage <bugprone-suspicious-enum-usage.html>`_,
    `bugprone-suspicious-include <bugprone-suspicious-include.html>`_,
    `bugprone-suspicious-memset-usage <bugprone-suspicious-memset-usage.html>`_, "Yes"
    `bugprone-suspicious-missing-comma <bugprone-suspicious-missing-comma.html>`_,
    `bugprone-suspicious-semicolon <bugprone-suspicious-semicolon.html>`_, "Yes"
.. csv-table::
    `readability-uniqueptr-delete-release <readability-uniqueptr-delete-release.html>`_, "Yes"
    `readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_, "Yes"
    `zircon-temporary-objects <zircon-temporary-objects.html>`_,
 
 
 .. csv-table:: Aliases..
    :header: "Name", "Redirect", "Offers fixes"
 
+   `cert-con36-c <cert-con36-c.html>`_, `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
+   `cert-con54-cpp <cert-con54-cpp.html>`_, `bugprone-spuriously-wake-up-functions <bugprone-spuriously-wake-up-functions.html>`_,
    `cert-dcl03-c <cert-dcl03-c.html>`_, `misc-static-assert <misc-static-assert.html>`_, "Yes"
    `cert-dcl16-c <cert-dcl16-c.html>`_, `readability-uppercase-literal-suffix <readability-uppercase-literal-suffix.html>`_, "Yes"
    `cert-dcl37-c <cert-dcl37-c.html>`_, `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_, "Yes"
    `cert-dcl51-cpp <cert-dcl51-cpp.html>`_, `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_, "Yes"
    `cert-dcl54-cpp <cert-dcl54-cpp.html>`_, `misc-new-delete-overloads <misc-new-delete-overloads.html>`_,
    `cert-dcl59-cpp <cert-dcl59-cpp.html>`_, `google-build-namespaces <google-build-namespaces.html>`_,
    `cert-err09-cpp <cert-err09-cpp.html>`_, `misc-throw-by-value-catch-by-reference <misc-throw-by-value-catch-by-reference.html>`_,
    `cert-err61-cpp <cert-err61-cpp.html>`_, `misc-throw-by-value-catch-by-reference <misc-throw-by-value-catch-by-reference.html>`_,

clang-tools-extra/test/clang-tidy/checkers/bugprone-spuriously-wake-up-functions.c

+// RUN: %check_clang_tidy %s bugprone-spuriously-wake-up-functions %t -- --
+#define NULL 0
+
+struct Node1 {
+  void *Node1;
+  struct Node1 *next;
+};
+
+typedef struct mtx_t {
+} mtx_t;
+typedef struct cnd_t {
+} cnd_t;
+struct timespec {};
+
+int cnd_wait(cnd_t *cond, mtx_t *mutex){};
+int cnd_timedwait(cnd_t *cond, mtx_t *mutex,
+                  const struct timespec *time_point){};
+
+struct Node1 list_c;
+static mtx_t lock;
+static cnd_t condition_c;
+struct timespec ts;
+
+void consume_list_element(void) {
+
+  if (list_c.next == NULL) {
+    if (0 != cnd_wait(&condition_c, &lock)) {
+      // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 'cnd_wait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+    }
+  }
+  if (list_c.next == NULL)
+    if (0 != cnd_wait(&condition_c, &lock))
+      // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 'cnd_wait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+      ;
+  if (list_c.next == NULL && 0 != cnd_wait(&condition_c, &lock))
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: 'cnd_wait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+    ;
+  while (list_c.next == NULL) {
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  }
+  while (list_c.next == NULL)
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  while (list_c.next == NULL)
+    if (0 != cnd_wait(&condition_c, &lock))
+      ;
+  if (list_c.next == NULL) {
+    cnd_wait(&condition_c, &lock);
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'cnd_wait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+  }
+  if (list_c.next == NULL)
+    cnd_wait(&condition_c, &lock);
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'cnd_wait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+  while (list_c.next == NULL) {
+    cnd_wait(&condition_c, &lock);
+  }
+  while (list_c.next == NULL)
+    cnd_wait(&condition_c, &lock);
+
+  do {
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  } while (list_c.next == NULL);
+  do
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  while (list_c.next == NULL);
+  do
+    if (0 != cnd_wait(&condition_c, &lock))
+      ;
+  while (list_c.next == NULL);
+  do {
+    cnd_wait(&condition_c, &lock);
+  } while (list_c.next == NULL);
+  do
+    cnd_wait(&condition_c, &lock);
+  while (list_c.next == NULL);
+  for (;; list_c.next == NULL) {
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  }
+  for (;; list_c.next == NULL)
+    if (0 != cnd_wait(&condition_c, &lock)) {
+    }
+  for (;; list_c.next == NULL)
+    if (0 != cnd_wait(&condition_c, &lock))
+      ;
+  for (;; list_c.next == NULL) {
+    cnd_wait(&condition_c, &lock);
+  }
+  for (;; list_c.next == NULL)
+    cnd_wait(&condition_c, &lock);
+
+  if (list_c.next == NULL) {
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+      // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 'cnd_timedwait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+    }
+  }
+  if (list_c.next == NULL)
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts))
+      // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 'cnd_timedwait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+      ;
+  if (list_c.next == NULL && 0 != cnd_timedwait(&condition_c, &lock, &ts))
+    // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: 'cnd_timedwait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+    ;
+  while (list_c.next == NULL) {
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  }
+  while (list_c.next == NULL)
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  while (list_c.next == NULL)
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts))
+      ;
+  if (list_c.next == NULL) {
+    cnd_timedwait(&condition_c, &lock, &ts);
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'cnd_timedwait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+  }
+  if (list_c.next == NULL)
+    cnd_timedwait(&condition_c, &lock, &ts);
+  // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'cnd_timedwait' should be placed inside a while statement [bugprone-spuriously-wake-up-functions]
+  while (list_c.next == NULL) {
+    cnd_timedwait(&condition_c, &lock, &ts);
+  }
+  while (list_c.next == NULL)
+    cnd_timedwait(&condition_c, &lock, &ts);
+
+  do {
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  } while (list_c.next == NULL);
+  do
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  while (list_c.next == NULL);
+  do
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts))
+      ;
+  while (list_c.next == NULL);
+  do {
+    cnd_timedwait(&condition_c, &lock, &ts);
+  } while (list_c.next == NULL);
+  do
+    cnd_timedwait(&condition_c, &lock, &ts);
+  while (list_c.next == NULL);
+  for (;; list_c.next == NULL) {
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  }
+  for (;; list_c.next == NULL)
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts)) {
+    }
+  for (;; list_c.next == NULL)
+    if (0 != cnd_timedwait(&condition_c, &lock, &ts))
+      ;
+  for (;; list_c.next == NULL) {
+    cnd_timedwait(&condition_c, &lock, &ts);
+  }
+  for (;; list_c.next == NULL)
+    cnd_timedwait(&condition_c, &lock, &ts);
+}
+int main() { return 0; }

clang-tools-extra/test/clang-tidy/checkers/bugprone-spuriously-wake-up-functions.cpp

+// RUN: %check_clang_tidy %s bugprone-spuriously-wake-up-functions %t -- --
+#define NULL 0
+
+namespace std {
+using intmax_t = int;
+
+template <intmax_t N, intmax_t D = 1>
+class ratio {
+public:
+  static constexpr intmax_t num = 0;
+  static constexpr intmax_t den = 0;
+  typedef ratio<num, den> type;
+};
+typedef ratio<1, 1000> milli;
+namespace chrono {
+
+template <class Rep, class Period = ratio<1>>
+class duration {
+public:
+  using rep = Rep;
+  using period = Period;
+
+public:
+  constexpr duration() = default;
+  template <class Rep2>
+  constexpr explicit duration(const Rep2 &r);
+  template <class Rep2, class Period2>
+  constexpr duration(const duration<Rep2, Period2> &d);
+  ~duration() = default;
+  duration(const duration &) = default;
+};
+
+template <class Clock, class Duration = typename Clock::duration>
+class time_point {
+public:
+  using clock = Clock;
+  using duration = Duration;
+
+public:
+  constexpr time_point();
+  constexpr explicit time_point(const duration &d);
+  template <class Duration2>
+  constexpr time_point(const time_point<clock, Duration2> &t);
+};
+
+using milliseconds = duration<int, milli>;
+
+class system_clock {
+public:
+  typedef milliseconds duration;
+  typedef duration::rep rep;
+  typedef duration::period period;
+  typedef chrono::time_point<system_clock> time_point;
+
+  static time_point now() noexcept;
+};
+} // namespace chrono
+
+class mutex;
+template <class Mutex>
+class unique_lock {
+public:
+  typedef Mutex mutex_type;
+
+  unique_lock() noexcept;
+  explicit unique_lock(mutex_type &m);
+};
+
+class mutex {
+public:
+  constexpr mutex() noexcept;
+  ~mutex();
+  mutex(const mutex &) = delete;
+  mutex &operator=(const mutex &) = delete;
+};
+
+enum class cv_status {
+  no_timeout,
+  timeout
+};
+
+class condition_variable {
+public:
+  condition_variable();
+  ~condition_variable();
+  condition_variable(const condition_variable &) = delete;
+
+  void wait(unique_lock<mutex> &lock);
+  template <class Predicate>
+  void wait(unique_lock<mutex> &lock, Predicate pred);
+  template <class Clock, class Duration>
+  cv_status wait_until(unique_lock<mutex> &lock,
+                       const chrono::time_point<Clock, Duration> &abs_time){};
+  template <class Clock, class Duration, class Predicate>
+  bool wait_until(unique_lock<mutex> &lock,
+                  const chrono::time_point<Clock, Duration> &abs_time,
+                  Predicate pred){};
+  template <class Rep, class Period>
+  cv_status wait_for(unique_lock<mutex> &lock,
+                     const chrono::duration<Rep, Period> &rel_time){};
+  template <class Rep, class Period, class Predicate>
+  bool wait_for(unique_lock<mutex> &lock,
+                const chrono::duration<Rep, Period> &rel_time,
+                Predicate pred){};
+};
+
+} // namespace std
+
+struct Node1 {
+  void *Node1;
+  struct Node1 *next;
+};
+
+static Node1 list;
+static std::mutex m;
+static std::condition_variable condition;
+
+void consume_list_element(std::condition_variable &condition) {
+  std::unique_lock<std::mutex> lk(m);
+
+  if (list.next == nullptr) {
+    condition.wait(lk);
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: 'wait' should be placed inside a while statement or used with a conditional parameter [bugprone-spuriously-wake-up-functions]
+  }
+
+  while (list.next == nullptr) {
+    condition.wait(lk);
+  }
+
+  do {
+    condition.wait(lk);
+  } while (list.next == nullptr);
+
+  for (;; list.next == nullptr) {
+    condition.wait(lk);
+  }
+
+  if (list.next == nullptr) {
+    while (list.next == nullptr) {
+      condition.wait(lk);
+    }
+  }
+
+  if (list.next == nullptr) {
+    do {
+      condition.wait(lk);
+    } while (list.next == nullptr);
+  }
+
+  if (list.next == nullptr) {
+    for (;; list.next == nullptr) {
+      condition.wait(lk);
+    }
+  }
+  using durtype = std::chrono::duration<int, std::milli>;
+  durtype dur = std::chrono::duration<int, std::milli>();
+  if (list.next == nullptr) {
+    condition.wait_for(lk, dur);
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: 'wait_for' should be placed inside a while statement or used with a conditional parameter [bugprone-spuriously-wake-up-functions]
+  }
+  if (list.next == nullptr) {
+    condition.wait_for(lk, dur, [] { return 1; });
+  }
+  while (list.next == nullptr) {
+    condition.wait_for(lk, dur);
+  }
+  do {
+    condition.wait_for(lk, dur);
+  } while (list.next == nullptr);
+  for (;; list.next == nullptr) {
+    condition.wait_for(lk, dur);
+  }
+
+  auto now = std::chrono::system_clock::now();
+  if (list.next == nullptr) {
+    condition.wait_until(lk, now);
+    // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: 'wait_until' should be placed inside a while statement or used with a conditional parameter [bugprone-spuriously-wake-up-functions]
+  }
+  if (list.next == nullptr) {
+    condition.wait_until(lk, now, [] { return 1; });
+  }
+  while (list.next == nullptr) {
+    condition.wait_until(lk, now);
+  }
+  do {
+    condition.wait_until(lk, now);
+  } while (list.next == nullptr);
+  for (;; list.next == nullptr) {
+    condition.wait_until(lk, now);
+  }
+}