[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

20

Unnecessary empty line.

clang-tools-extra/docs/ReleaseNotes.rst

112

Please add empty line above.

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

12

Should be double colon.

18

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

89

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

83–85

Please use check here.

[abelkocsis]

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

83–85

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

83–85

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

84

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 "MisplacedPointerArithmeticInAllocCheck.h"
 #include "MisplacedWideningCastCheck.h"
 #include "MoveForwardingReferenceCheck.h"
 #include "MultipleStatementMacroCheck.h"
 #include "NotNullTerminatedResultCheck.h"
 #include "ParentVirtualCallCheck.h"
 #include "PosixReturnCheck.h"
 #include "ReservedIdentifierCheck.h"
+#include "SignalInMultithreadedProgramCheck.h"
 #include "SignedCharMisuseCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     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<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<StringConstructorCheck>(
         "bugprone-string-constructor");

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

add_clang_library(clangTidyBugproneModule
   MisplacedPointerArithmeticInAllocCheck.cpp
   MisplacedWideningCastCheck.cpp
   MoveForwardingReferenceCheck.cpp
   MultipleStatementMacroCheck.cpp
   NotNullTerminatedResultCheck.cpp
   ParentVirtualCallCheck.cpp
   PosixReturnCheck.cpp
   ReservedIdentifierCheck.cpp
+  SignalInMultithreadedProgramCheck.cpp
   SignedCharMisuseCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousMemsetUsageCheck.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"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Finds ``signal`` function calls when the program is multithreaded. It
+/// founds a program multithreaded when it finds at least one function call
+/// of the following: ``thrd_create``, ``std::thread``, ``boost::thread``,
+/// ``dlib::thread_function``, ``dlib::thread_pool``,
+/// ``dlib::default_thread_pool``, ``pthread_t``.
+///
+/// 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) {}
+  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_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 "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+void SignalInMultithreadedProgramCheck::registerMatchers(MatchFinder *Finder) {
+
+  auto signalCall =
+      callExpr(
+          ignoringImpCasts(hasDescendant(declRefExpr(hasDeclaration(
+              functionDecl(allOf(hasName("signal"), parameterCountIs(2),
+                                 hasParameter(0, hasType(isInteger())))))))))
+          .bind("signal");
+
+  auto threadCall = callExpr(ignoringImpCasts(
+      hasDescendant(declRefExpr(hasDeclaration(functionDecl(hasAnyName(
+          "thrd_create", "::thread", "boost::thread", "dlib::thread_function",
+          "dlib::thread_pool", "dlib::default_thread_pool", "pthread_t")))))));
+
+  Finder->addMatcher(translationUnitDecl(allOf(hasDescendant(signalCall),
+                                               hasDescendant(threadCall))),
+                     this);
+}
+
+void SignalInMultithreadedProgramCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  const auto *MatchedSignal = Result.Nodes.getNodeAs<CallExpr>("signal");
+  diag(MatchedSignal->getExprLoc(),
+       "singal function should not be called in a multithreaded program");
+}
+
+} // 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/SignalInMultithreadedProgramCheck.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"

 class CERTModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     // C++ checkers
     // 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
+    // CON
+    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:`bugprone-misplaced-pointer-arithmetic-in-alloc
   result of a memory allocation function (``malloc()``, ``calloc()``,
   ``realloc()``, ``alloca()``) instead of its argument.
 
 - 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-signal-in-multithreaded-program
+  <clang-tidy/checks/bugprone-signal-in-multithreaded-program>` check.
+
+  Finds ``signal`` function calls when the program is multithreaded. It
+  founds a program multithreaded when it finds at least one function call
+  of the following: ``thrd_create``, ``std::thread``, ``boost::thread``,
+  ``dlib::thread_function``, ``dlib::thread_pool``,
+  ``dlib::default_thread_pool``, ``pthread_t``.
+
 - New :doc:`cert-oop57-cpp
   <clang-tidy/checks/cert-oop57-cpp>` check.
 
   Flags use of the `C` standard library functions ``memset``, ``memcpy`` and
   ``memcmp`` and similar derivatives on non-trivial types.
 
 - New :doc:`objc-dealloc-in-category
   <clang-tidy/checks/objc-dealloc-in-category>` check.
 
   Finds implementations of -dealloc in Objective-C categories.
 
 - 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-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-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

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. It founds a
+program multithreaded when it finds at least one function call of the 
+following: ``thrd_create``, ``std::thread``, ``boost::thread``,
+``dlib::thread_function``, ``dlib::thread_pool``,
+``dlib::default_thread_pool``, ``pthread_t``.
+
+.. 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>`_.

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-misplaced-pointer-arithmetic-in-alloc <bugprone-misplaced-pointer-arithmetic-in-alloc.html>`_, "Yes"
    `bugprone-misplaced-widening-cast <bugprone-misplaced-widening-cast.html>`_,
    `bugprone-move-forwarding-reference <bugprone-move-forwarding-reference.html>`_, "Yes"
    `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-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-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-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-con37-c <cert-con37-c.html>`_,
    `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>`_,
    `cert-err34-c <cert-err34-c.html>`_,
    `cert-err52-cpp <cert-err52-cpp.html>`_,
    `cert-err58-cpp <cert-err58-cpp.html>`_,
    `cert-err60-cpp <cert-err60-cpp.html>`_,
    `cert-flp30-c <cert-flp30-c.html>`_,
    `cert-mem57-cpp <cert-mem57-cpp.html>`_,
    `cert-msc50-cpp <cert-msc50-cpp.html>`_,

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

+// 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: singal 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;
+}