[clang-tidy] Add signal-in-multithreaded-program check

[abelkocsis]

Summary

According to
https://wiki.sei.cmu.edu/confluence/display/c/CON37-C.+Do+not+call+signal%28%29+in+a+multithreaded+program
bugprone-signal-in-multithreaded-program check is created.
The check finds signal function call when the program is
multithreaded.

[Eugene.Zelenko]

Will be good idea to make callers function list configurable through option. See other checks as example.

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

21

Unnecessary empty line.

clang-tools-extra/docs/ReleaseNotes.rst

135

Please add empty line above.

clang-tools-extra/docs/clang-tidy/checks/bugprone-signal-in-multithreaded-program.rst

13

Should be double colon.

19

Please enclose signal() in double back-ticks.

[abelkocsis]

Configurable callers option and new test cases add.

[steakhal]

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

34–51

I apologize for interrupting the review.
Should we use hasDescendant for matching like everything in translation unit?

Wouldn't it be more performant to collect all the signal calls in a set and set a bool variable if a ThreadList function seen?
At the end of the analysis of the translation unit, emit warnings for each recorded signal call if the variable was set (aka. we are in multithreaded environment).

Treat this comment rather a question since I'm not really familiar with clang-tidy.

[abelkocsis]

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

34–51

I updated the checker not exactly in that way you mentioned, but I think you are right that we should not match for all translationUnitDecl.

[Charusso]

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

34–51

Every single check runs on the whole TranslationUnitDecl, and the matcher will try to match on every of the TU's descendant, that is why it emit multiple reports in the same single run. There is no need to use translationUnitDecl() and nor to use forEachDescendant().

39

You can emit the binding of thread.

57

singal -> signal

[abelkocsis]

Small fixes

[gamesh411]

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

24

founds -> finds, but I would rather reword it like this:
The checker considers the analyzed program multithreaded if it finds ....

clang-tools-extra/docs/ReleaseNotes.rst

101

Same as before.

[gamesh411]

Minor nits inline. Good job, I am not entitled to accept it, but LGTM!

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

24

Or better:
The check considers ...
as the term checker is used more in ClangSA, and check in clang-tidy.

[Eugene.Zelenko]

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

24

Clang-tidy uses check.

[abelkocsis]

Fixes on description and documentation

[Eugene.Zelenko]

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

89

Please use check here.

[abelkocsis]

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

89

Should I replace the // C++ checkers comment too? I mean to // C++ checks instead of // C++ checkers?

[Eugene.Zelenko]

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

89

Sure. It's good idea to keep user and developer terminology consistent.

[abelkocsis]

Small comment fix

[whisperity]

In general, the test files should be cleaned up.

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-config-std::thread.cpp

1 ↗

(On Diff #271789)

Please rename this file to something that doesn't conatain : in the name. Windows peoples' computers will explode if it's merged like this...

5–6 ↗

(On Diff #271789)

Are these definitions needed for C++ test?

32 ↗

(On Diff #271789)

As far as I know, int main(void) is not valid C++ code. Only int main() and int main(int, char**) are valid, see [basic.start.main]/2.

If we are writing C++ test code, let's make it appear as if it was C++ code.

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-noconfig-std::thread.cpp

1 ↗

(On Diff #271789)

Same rename here.

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-noconfig-thrd_create.cpp

1 ↗

(On Diff #271789)

thrd_create is a C standard function, and this file looks like a C file to me, so why is the extension .cpp?

[jfb]

It seems like you don't want this check to trigger on POSIX platforms, given:

Exceptions CON37-C-EX1: Implementations such as POSIX that provide defined behavior when multithreaded programs use custom signal handlers are exempt from this rule [IEEE Std 1003.1-2013].

[abelkocsis]

Fixes

[abelkocsis]

I have managed to improve the checker, but could not set up the test files to work only in POSIX platforms. Could you help me or show me an example?

[whisperity]

In D75229#2189666, @abelkocsis wrote:

I have managed to improve the checker, but could not set up the test files to work only in POSIX platforms. Could you help me or show me an example?

It's more so that, if I understand correctly, you don't want the diagnostics to be emitted when dealing with POSIX multithreading.

Also, have you checked in the test if __unix__ is defined? I'm not seeing any indication of targets in the test configuration, nor checking for this macro. Maybe a Windows-specific test file should be added? clang/test/Preprocessor/init.c lists a bunch of macros that are supposedly pre-defined based on the target.

Or maybe the OSType in the triple would be more useful than the vendor?

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

69

Global state is always a potential problem. Are you sure this is the right way to do things? Most other tidy checks that actively use this function define their own PPCallback subclass and use the existing preprocessor here to ensure the preprocessor executes the callback.

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

50–85

Please upload the diff with full context.

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

102

There is a table in this file towards the end where alias checks are explicitly listed in a "which check is alias of which other check" format.

[aaron.ballman]

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

42

::std::thread

48

::signal

57

This does not seem like the right way to check for POSIX -- isn't that _POSIX_C_SOURCE?

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

25

The comment is a bit stale as it also accepts user-defined functions. Note, I think CreateThread, CreateRemoteThread, _beginthread, and _beginthreadex should be added to the list as those are the common Win32 APIs for creating threads (where pthreads aren't available).

35

I think that should be ::std::thread and ::boost::thread to avoid pathological naming issues.

[abelkocsis]

Some fixes. Needs further improvement

[abelkocsis]

Fixes

[abelkocsis]

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

69

I've used the same way in another check (https://reviews.llvm.org/D69181). I'm not entirely sure which is the better way to do.

[aaron.ballman]

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

58

Nothing for you to change here, but this demonstrates that isLanguageVersionSupported() isn't sufficient. We don't want to register the check at all for POSIX platforms in the same way we don't want to register checks at all based on the language standard being enforced, but we can't because we can't get to the Preprocessor or target information from there.

69

Defining the PPCallback subclass is a better approach (https://github.com/llvm/llvm-project/blob/e40a742a5008c5a4cf647c0ea805486498786393/clang-tools-extra/clang-tidy/cert/SetLongJmpCheck.cpp#L49 shows a reasonable demonstration). At the very least, this doesn't have to set a global variable, it could set a member variable on SignalInMultithreadedProgramCheck.

I hadn't caught that in D69181, sorry about that!

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

25

The comment has gone stale again. Rather than listing the functions in the comment, I think it's fine to change it to: ... if it finds at least one threading-related function.

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

91

We try to keep these in order, so this should move down below con36-c.

[abelkocsis]

Fixes, PPCallbacks class add

[jfb]

Most of the tests as written should be failing right now, at least on macOS and Linux, because they likely should be identified as POSIX, right?

[abelkocsis]

Fix, MacroName == "__unix__" seems really necessary. Without that, it throws a warning for me on Linux.

[abelkocsis]

In D75229#2406758, @jfb wrote:

Most of the tests as written should be failing right now, at least on macOS and Linux, because they likely should be identified as POSIX, right?

Yes, now it fails on my system too. What would be the solution?

[njames93]

Can this be moved from bugprone to the new concurrency module added in D91656.

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

 #include "MultipleStatementMacroCheck.h"
 #include "NoEscapeCheck.h"
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
 #include "RedundantBranchConditionCheck.h"
 #include "ReservedIdentifierCheck.h"
 #include "SignalHandlerCheck.h"
+#include "SignalInMultithreadedProgramCheck.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"
CheckFactories.registerCheck<NotNullTerminatedResultCheck>(
         "bugprone-not-null-terminated-result");
     CheckFactories.registerCheck<ParentVirtualCallCheck>(
         "bugprone-parent-virtual-call");
     CheckFactories.registerCheck<PosixReturnCheck>(
         "bugprone-posix-return");
     CheckFactories.registerCheck<ReservedIdentifierCheck>(
         "bugprone-reserved-identifier");
     CheckFactories.registerCheck<SignalHandlerCheck>("bugprone-signal-handler");
+    CheckFactories.registerCheck<SignalInMultithreadedProgramCheck>(
+        "bugprone-signal-in-multithreaded-program");
     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");

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

add_clang_library(clangTidyBugproneModule
   MultipleStatementMacroCheck.cpp
   NoEscapeCheck.cpp
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
   RedundantBranchConditionCheck.cpp
   ReservedIdentifierCheck.cpp
   SignalHandlerCheck.cpp
+  SignalInMultithreadedProgramCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   SpuriouslyWakeUpFunctionsCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp

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

+//===--- SignalInMultithreadedProgramCheck.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_SIGNALINMULTITHREADEDPROGRAMCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIGNALINMULTITHREADEDPROGRAMCHECK_H
+
+#include "../ClangTidyCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Finds ``signal`` function calls when the program is multithreaded. The
+/// check considers the analyzed program multithreaded if it finds at least
+/// one threading-related function.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-signal-in-multithreaded-program.html
+class SignalInMultithreadedProgramCheck : public ClangTidyCheck {
+public:
+  SignalInMultithreadedProgramCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context),
+        ThreadList(Options.get(
+            "ThreadList",
+            "thrd_create;::std::thread;::boost::thread;pthread_t;CreateThread;"
+            "CreateRemoteThread;_beginthread;_beginthreadex")) {}
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+  void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
+                           Preprocessor *ModuleExpanderPP) override;
+  bool IsCPosix = false;
+
+private:
+  const std::string ThreadList;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_SIGNALINMULTITHREADEDPROGRAMCHECK_H

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

+//===--- SignalInMultithreadedProgramCheck.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 "SignalInMultithreadedProgramCheck.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Lex/Preprocessor.h"
+
+using namespace clang::ast_matchers;
+using namespace clang::ast_matchers::internal;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+namespace {
+class SignalInMultithreadedPPCallbacks : public PPCallbacks {
+public:
+  explicit SignalInMultithreadedPPCallbacks(
+      SignalInMultithreadedProgramCheck &Check, const SourceManager &SM,
+      Preprocessor *PP)
+      : Check(Check), PP(PP) {}
+  void MacroDefined(const Token &MacroNameTok,
+                    const MacroDirective *MD) override {
+    const llvm::StringRef MacroName = MacroNameTok.getIdentifierInfo()->getName();
+    if (MacroName == "_POSIX_C_SOURCE" || MacroName == "__unix__") {
+      Check.IsCPosix = true;
+    }
+  }
+
+private:
+  SignalInMultithreadedProgramCheck &Check;
+  Preprocessor *PP;
+};
+} // namespace
+
+Matcher<FunctionDecl> hasAnyListedName(const std::string &FunctionNames) {
+  const std::vector<std::string> NameList =
+      utils::options::parseStringList(FunctionNames);
+  return hasAnyName(std::vector<StringRef>(NameList.begin(), NameList.end()));
+}
+
+void SignalInMultithreadedProgramCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "ThreadList", ThreadList);
+}
+
+void SignalInMultithreadedProgramCheck::registerMatchers(MatchFinder *Finder) {
+
+  auto threadCall = anyOf(
+      hasDescendant(callExpr(ignoringImpCasts(hasDescendant(declRefExpr(
+          hasDeclaration(functionDecl(hasAnyListedName(ThreadList)))))))),
+      hasDescendant(varDecl(hasType(recordDecl(hasName("::std::thread")))))
+
+  );
+  Finder->addMatcher(
+      callExpr(
+          ignoringImpCasts(hasDescendant(declRefExpr(hasDeclaration(
+              functionDecl(allOf(hasName("::signal"), parameterCountIs(2),
+                                 hasParameter(0, hasType(isInteger())))))))),
+          hasAncestor(compoundStmt(threadCall)))
+          .bind("signal"),
+      this);
+}
+
+void SignalInMultithreadedProgramCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  bool IsPosix =
+      IsCPosix || Result.Context->getTargetInfo().getTriple().getVendor() ==
+                      llvm::Triple::Apple;
+  if (IsPosix)
+    return;
+  const auto *MatchedSignal = Result.Nodes.getNodeAs<CallExpr>("signal");
+  diag(MatchedSignal->getExprLoc(),
+       "signal function should not be called in a multithreaded program");
+}
+
+void SignalInMultithreadedProgramCheck::registerPPCallbacks(
+    const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
+  PP->addPPCallbacks(
+      ::std::make_unique<SignalInMultithreadedPPCallbacks>(*this, SM, PP));
+}
+
+} // 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/SignalHandlerCheck.h"
+#include "../bugprone/SignalInMultithreadedProgramCheck.h"
 #include "../bugprone/SignedCharMisuseCheck.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"

 
 namespace clang {
 namespace tidy {
 namespace cert {
 
 class CERTModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
-    // C++ checkers
+    // C++ checks
     // 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");
     CheckFactories.registerCheck<DontModifyStdNamespaceCheck>(
         "cert-dcl58-cpp");
     CheckFactories.registerCheck<google::build::UnnamedNamespaceInHeaderCheck>(
         "cert-dcl59-cpp");
     // ERR
     CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
         "cert-err09-cpp");
     CheckFactories.registerCheck<SetLongJmpCheck>("cert-err52-cpp");
     CheckFactories.registerCheck<StaticObjectExceptionCheck>("cert-err58-cpp");
     CheckFactories.registerCheck<ThrownExceptionTypeCheck>("cert-err60-cpp");
     CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
         "cert-err61-cpp");
     // MEM
     CheckFactories.registerCheck<DefaultOperatorNewAlignmentCheck>(
         "cert-mem57-cpp");
     // MSC
     CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
     CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(
         "cert-msc51-cpp");
     // OOP
     CheckFactories.registerCheck<performance::MoveConstructorInitCheck>(
         "cert-oop11-cpp");
     CheckFactories.registerCheck<bugprone::UnhandledSelfAssignmentCheck>(
         "cert-oop54-cpp");
     CheckFactories.registerCheck<NonTrivialTypesLibcMemoryCallsCheck>(
         "cert-oop57-cpp");
     CheckFactories.registerCheck<MutatingCopyCheck>(
         "cert-oop58-cpp");
 
-    // C checkers
+    // C checks
     // CON
     CheckFactories.registerCheck<bugprone::SpuriouslyWakeUpFunctionsCheck>(
         "cert-con36-c");
+    CheckFactories.registerCheck<bugprone::SignalInMultithreadedProgramCheck>(
+        "cert-con37-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

 
 - New :doc:`altera-struct-pack-align
   <clang-tidy/checks/altera-struct-pack-align>` check.
 
   Finds structs that are inefficiently packed or aligned, and recommends
   packing and/or aligning of said structs as needed.
 
 - New :doc:`cppcoreguidelines-prefer-member-initializer
   <clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
 
   Finds member initializations in the constructor body which can be placed into
   the initialization list instead.
 
 - New :doc:`bugprone-misplaced-pointer-arithmetic-in-alloc
   <clang-tidy/checks/bugprone-misplaced-pointer-arithmetic-in-alloc>` check.
 
 - New :doc:`bugprone-redundant-branch-condition
   <clang-tidy/checks/bugprone-redundant-branch-condition>` check.
 
   Finds condition variables in nested ``if`` statements that were also checked
   in the outer ``if`` statement and were not changed.
 
 - New :doc:`bugprone-signal-handler
   <clang-tidy/checks/bugprone-signal-handler>` check.
 
   Finds functions registered as signal handlers that call non asynchronous-safe
   functions.
 
+- New :doc:`bugprone-signal-in-multithreaded-program
+  <clang-tidy/checks/bugprone-signal-in-multithreaded-program>` check.
+
+  Finds ``signal`` function calls when the program is multithreaded. The
+  check considers the analyzed program multithreaded if it finds at least 
+  one threading-related function.
+
+- New :doc:`bugprone-suspicious-include
+  <clang-tidy/checks/bugprone-suspicious-include>` check.
+
 - New :doc:`cert-sig30-c
   <clang-tidy/checks/cert-sig30-c>` check.
 
   Alias to the :doc:`bugprone-signal-handler
   <clang-tidy/checks/bugprone-signal-handler>` check.
 
 - New :doc:`readability-function-cognitive-complexity
   <clang-tidy/checks/readability-function-cognitive-complexity>` check.
 
   Flags functions with Cognitive Complexity metric exceeding the configured limit.
 
+- New alias :doc:`cert-con37-c
+  <clang-tidy/checks/cert-con37-c>` to
+  :doc:`bugprone-signal-in-multithreaded-program
+  <clang-tidy/checks/bugprone-signal-in-multithreaded-program>` 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.
+
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`modernize-loop-convert
   <clang-tidy/checks/modernize-loop-convert>` check.
 
   Now able to transform iterator loops using ``rbegin`` and ``rend`` methods.
 

clang-tools-extra/docs/clang-tidy/checks/bugprone-signal-in-multithreaded-program.rst

+.. title:: clang-tidy - bugprone-signal-in-multithreaded-program
+
+bugprone-signal-in-multithreaded-program
+========================================
+
+Finds ``signal`` function calls when the program is multithreaded. The
+check considers the analyzed program multithreaded if it finds at least 
+one threading-related function.
+
+.. code-block:: c
+
+    signal(SIGUSR1, handler);
+    thrd_t tid;
+
+This check corresponds to the CERT C++ Coding Standard rule
+`CON37-C. Do not call signal() in a multithreaded program
+<https://wiki.sei.cmu.edu/confluence/display/c/CON37-C.+Do+not+call+signal%28%29+in+a+multithreaded+program>`_.
+
+Options
+-------
+
+.. option:: ThreadList
+
+   Semicolon-separated list of fully qualified names of thread call functions.
+   Defaults to ``thrd_create;::thread;boost::thread;pthread_t``.

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

+.. title:: clang-tidy - cert-con37-c
+.. meta::
+   :http-equiv=refresh: 5;URL=bugprone-signal-in-multithreaded-program.html
+
+cert-con37-c
+============
+
+The cert-con37-c check is an alias, please see
+`bugprone-signal-in-multithreaded-program <bugprone-signal-in-multithreaded-program.html>`_ 
+for more information.

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

.. csv-table::
    `bugprone-multiple-statement-macro <bugprone-multiple-statement-macro.html>`_,
    `bugprone-no-escape <bugprone-no-escape.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-redundant-branch-condition <bugprone-redundant-branch-condition.html>`_, "Yes"
    `bugprone-reserved-identifier <bugprone-reserved-identifier.html>`_, "Yes"
    `bugprone-signal-handler <bugprone-signal-handler.html>`_,
+   `bugprone-signal-in-multithreaded-program <bugprone-signal-in-multithreaded-program.html>`_,
    `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"
    `bugprone-suspicious-string-compare <bugprone-suspicious-string-compare.html>`_, "Yes"
    `bugprone-swapped-arguments <bugprone-swapped-arguments.html>`_, "Yes"
    `bugprone-terminating-continue <bugprone-terminating-continue.html>`_, "Yes"
    `bugprone-throw-keyword-missing <bugprone-throw-keyword-missing.html>`_,
    `bugprone-too-small-loop-variable <bugprone-too-small-loop-variable.html>`_,
    `bugprone-undefined-memory-manipulation <bugprone-undefined-memory-manipulation.html>`_,
    `bugprone-undelegated-constructor <bugprone-undelegated-constructor.html>`_,
    `bugprone-unhandled-self-assignment <bugprone-unhandled-self-assignment.html>`_,
    `bugprone-unused-raii <bugprone-unused-raii.html>`_, "Yes"
    `bugprone-unused-return-value <bugprone-unused-return-value.html>`_,
    `bugprone-use-after-move <bugprone-use-after-move.html>`_,
    `bugprone-virtual-near-miss <bugprone-virtual-near-miss.html>`_, "Yes"
    `cert-dcl21-cpp <cert-dcl21-cpp.html>`_,
    `cert-dcl50-cpp <cert-dcl50-cpp.html>`_,
    `cert-dcl58-cpp <cert-dcl58-cpp.html>`_,
    `cert-env33-c <cert-env33-c.html>`_,
.. csv-table::
    `readability-use-anyofallof <readability-use-anyofallof.html>`_,
    `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-con37-c <cert-con37-c.html>`_, `bugprone-signal-in-multithreaded-program <bugprone-signal-in-multithreaded-program>`_,
    `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>`_,

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-config-std_thread.cpp

+// RUN: %check_clang_tidy %s bugprone-signal-in-multithreaded-program %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: bugprone-signal-in-multithreaded-program.ThreadList, value: "::thread"}]}'
+
+typedef int sig_atomic_t;
+#define SIGUSR1 30
+#define NULL 0
+
+void (*signal(int sig, void (*handler)(int)))(int);
+
+volatile sig_atomic_t flag = 0;
+
+void handler(int signum) {
+  flag = 1;
+}
+
+void threadFunction() {}
+
+namespace std {
+class thread {
+public:
+  thread() noexcept;
+  template <class Function, class... Args>
+  explicit thread(Function &&f, Args &&... args);
+  thread(const thread &) = delete;
+  thread(thread &&) noexcept;
+};
+} // namespace std
+
+int main() {
+  signal(SIGUSR1, handler);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: signal function should not be called in a multithreaded program [bugprone-signal-in-multithreaded-program]
+
+  std::thread threadObj(threadFunction);
+
+  return 0;
+}

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-config-thrd_create.c

+// RUN: %check_clang_tidy %s bugprone-signal-in-multithreaded-program %t \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: bugprone-signal-in-multithreaded-program.ThreadList, value: "thrd_create"}]}'
+
+typedef unsigned long int thrd_t;
+typedef int (*thrd_start_t)(void *);
+typedef int sig_atomic_t;
+#define SIGUSR1 30
+#define NULL 0
+
+void (*signal(int sig, void (*handler)(int)))(int);
+
+int thrd_create(thrd_t *thr, thrd_start_t func, void *arg) { return 0; };
+enum {
+  thrd_success = 0,
+};
+
+volatile sig_atomic_t flag = 0;
+
+void handler(int signum) {
+  flag = 1;
+}
+
+int func(void *data) {
+  while (!flag) {
+  }
+  return 0;
+}
+
+int main(void) {
+  signal(SIGUSR1, handler);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: signal function should not be called in a multithreaded program [bugprone-signal-in-multithreaded-program]
+  thrd_t tid;
+
+  if (thrd_success != thrd_create(&tid, func, NULL)) {
+  }
+  return 0;
+}

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-noconfig-std_thread.cpp

+// RUN: %check_clang_tidy %s bugprone-signal-in-multithreaded-program %t
+
+typedef int sig_atomic_t;
+#define SIGUSR1 30
+#define NULL 0
+
+void (*signal(int sig, void (*handler)(int)))(int);
+
+volatile sig_atomic_t flag = 0;
+
+void handler(int signum) {
+  flag = 1;
+}
+
+void threadFunction() {}
+
+namespace std {
+class thread {
+public:
+  thread() noexcept;
+  template <class Function, class... Args>
+  explicit thread(Function &&f, Args &&... args);
+  thread(const thread &) = delete;
+  thread(thread &&) noexcept;
+};
+} // namespace std
+
+int main() {
+  signal(SIGUSR1, handler);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: signal function should not be called in a multithreaded program [bugprone-signal-in-multithreaded-program]
+
+  std::thread threadObj(threadFunction);
+
+  return 0;
+}

clang-tools-extra/test/clang-tidy/checkers/bugprone-signal-in-multithreaded-program-noconfig-thrd_create.c

+// RUN: %check_clang_tidy %s bugprone-signal-in-multithreaded-program %t
+
+typedef unsigned long int thrd_t;
+typedef int (*thrd_start_t)(void *);
+typedef int sig_atomic_t;
+#define SIGUSR1 30
+#define NULL 0
+
+void (*signal(int sig, void (*handler)(int)))(int);
+
+int thrd_create(thrd_t *thr, thrd_start_t func, void *arg) { return 0; };
+enum {
+  thrd_success = 0,
+};
+
+volatile sig_atomic_t flag = 0;
+
+void handler(int signum) {
+  flag = 1;
+}
+
+int func(void *data) {
+  while (!flag) {
+  }
+  return 0;
+}
+
+int main(void) {
+  signal(SIGUSR1, handler);
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: signal function should not be called in a multithreaded program [bugprone-signal-in-multithreaded-program]
+  thrd_t tid;
+
+  if (thrd_success != thrd_create(&tid, func, NULL)) {
+  }
+  return 0;
+}