[clang-tidy] Add check for CERT-OOP57-CPP

[njames93]

Summary

This is a very basic warning implementation of Prefer special member functions and overloaded operators to C Standard Library functions

It absolutely needs some fine tuning though.

[Eugene.Zelenko]

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

51 ↗

(On Diff #237229)

Please add check for C++.

clang-tools-extra/docs/ReleaseNotes.rst

70

Is this relevant?

72

Please separate with empty line and synchronize with first statement in documentation.

Please highlight memset, memcpy, memmove, strcpy, memcmp and strcmp with double back-ticks.

[Eugene.Zelenko]

It may be reasonable to provide options to expand list of problematic functions. See bugprone-suspicious-string-compare as example.

[njames93]

Added a way to specify custom mem set copy and compare functions plus nit fixes

Can now use the options MemSetNames, MemCpyNames and MemCmpNames to specify custom functions to flag on

clang-tools-extra/docs/ReleaseNotes.rst

70

nope, I renamed the check left that in , will remove

[Eugene.Zelenko]

Please describe options in documentation. See other checks documentation as example.

clang-tools-extra/docs/ReleaseNotes.rst

73

Please remove This check. Same in documentation.

[njames93]

Tweaked a few documentation issues

[Eugene.Zelenko]

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

75 ↗

(On Diff #237367)

Unnecessary empty line.

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

15

I look on other checks documentation and indentation for options is 3 characters.

[njames93]

• Fix format of options docs and remove unnecessary empty line

[Eugene.Zelenko]

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

15

Please enclose memset in double back-ticks. Same for other options.

16

Please append dot. Same for other options.

17

This is tautological because extra functions assume additions to functions handled by default. Same for other options.

[njames93]

• Fixed more documentation nits

[Eugene.Zelenko]

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

17

This repeats first sentence in documentation, so it should be removed. Same in other places.

[njames93]

• Reworked options documentation

[Eugene.Zelenko]

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

15

Somehow memset is still not in double back-ticks. Same for other options.

[njames93]

Figured out what memset you meant...

[aaron.ballman]

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

33–44 ↗

(On Diff #237492)

I think these should also include the w variants of the calls.

Other APIs to consider: strncmp, strncpy, and memccpy (note the extra c in the name) as all of these are part of the C standard these days.

You may also want to look through the POSIX docs to see if we should add those APIs as well (https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/string.h.html)

45 ↗

(On Diff #237492)

Was there a reason you were not also looking for the relational operators like < or >?

55–57 ↗

(On Diff #237492)

The formatting looks off here, but I would prefer if we could find a way to remove this code entirely. It looks very dangerous (StringRef is a non-owning data type) and also seems wasteful (you need two copies of the vector in memory at once).

The way it's being used seems to be safe and functional, but this still feels unclean.

75 ↗

(On Diff #237492)

I think this should probably also be disabled for ObjC. The CERT rule doesn't cover it, and I don't know enough about the "right way" to perform the comparisons there.

102 ↗

(On Diff #237492)

This can be lowered into its only use.

126 ↗

(On Diff #237492)

Calling -> calling
non trivially -> non-trivially

(Same comments apply to the other diagnostics.)

128 ↗

(On Diff #237492)

Rather than calling getName(), you can pass in the NamedDecl* directly and the diagnostic engine handles properly printing the name. e.g. getName(*Caller) should be cast<NamedDecl>(Caller->getCalleeDecl())

clang-tools-extra/clang-tidy/cert/NotTrivialTypesLibcMemoryCallsCheck.h

18 ↗

(On Diff #237492)

c -> C

23 ↗

(On Diff #237492)

I prefer the file to be named NonTrivialTypesLibcMemoryCallsCheck.h -- the Not looks strange to my eyes. Same for the class name.

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

13

You should specify that all of these options take a semicolon-delimited list of names.

[njames93]

• Fix a few nits, extra names will follow

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

33–44 ↗

(On Diff #237492)

I might hijack the list from bugprone-suspicous-string-compare too :)

75 ↗

(On Diff #237492)

Doesn't the CPlusPlus check block ObjC. Though it may not block ObjC++???

clang-tools-extra/clang-tidy/cert/NotTrivialTypesLibcMemoryCallsCheck.h

23 ↗

(On Diff #237492)

On looking so do I

[merge_guards_bot]

Unit tests: pass. 61850 tests passed, 0 failed and 781 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[njames93]

• remove This check from docs... again

[Eugene.Zelenko]

clang-tools-extra/docs/ReleaseNotes.rst

76

Please use double back-ticks to highlight function names.

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

7

Please use double back-ticks to highlight function names.

[merge_guards_bot]

Unit tests: fail. 61849 tests passed, 1 failed and 781 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_mutex_requirements_mutex/thread_mutex_class/try_lock.pass.cpp

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[merge_guards_bot]

Unit tests: pass. 61850 tests passed, 0 failed and 781 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[njames93]

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

7

Thats what i get for c&p

[njames93]

• double ticks

[merge_guards_bot]

Unit tests: pass. 61850 tests passed, 0 failed and 781 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aaron.ballman]

LGTM with a few nits.

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

72–75

I'd combine these into a single if.

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.h

26

You should do this formatting change, the per-merge check is actually correct for once. Don't bother with the ones in the test files though.

[njames93]

• added few more functions, fix format error

[merge_guards_bot]

Unit tests: pass. 61941 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[njames93]

• Fix If stmt and optimise building function name list

[merge_guards_bot]

Unit tests: pass. 61956 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[aaron.ballman]

Btw, do you need me to commit this on your behalf, or have you obtained your commit privileges?

[njames93]

• rebase truck

[merge_guards_bot]

Unit tests: pass. 62027 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[Eugene.Zelenko]

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

25

This should be in general documentation, not in option. Please enclose function names in double back-ticks.

Same for other similar statements below.

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

 #include "../performance/MoveConstructorInitCheck.h"
 #include "../readability/UppercaseLiteralSuffixCheck.h"
 #include "CommandProcessorCheck.h"
 #include "DefaultOperatorNewAlignmentCheck.h"
 #include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
 #include "MutatingCopyCheck.h"
+#include "NonTrivialTypesLibcMemoryCallsCheck.h"
 #include "PostfixOperatorCheck.h"
 #include "ProperlySeededRandomGeneratorCheck.h"
 #include "SetLongJmpCheck.h"
 #include "StaticObjectExceptionCheck.h"
 #include "StrToNumCheck.h"
 #include "ThrownExceptionTypeCheck.h"
 #include "VariadicFunctionDefCheck.h"
 
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     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
     // DCL
     CheckFactories.registerCheck<misc::StaticAssertCheck>("cert-dcl03-c");
     CheckFactories.registerCheck<readability::UppercaseLiteralSuffixCheck>(
         "cert-dcl16-c");

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

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyCERTModule
   CERTTidyModule.cpp
   CommandProcessorCheck.cpp
   DefaultOperatorNewAlignmentCheck.cpp
   DontModifyStdNamespaceCheck.cpp
   FloatLoopCounter.cpp
   LimitedRandomnessCheck.cpp
   MutatingCopyCheck.cpp
+  NonTrivialTypesLibcMemoryCallsCheck.cpp
   PostfixOperatorCheck.cpp
   ProperlySeededRandomGeneratorCheck.cpp
   SetLongJmpCheck.cpp
   StaticObjectExceptionCheck.cpp
   StrToNumCheck.cpp
   ThrownExceptionTypeCheck.cpp
   VariadicFunctionDefCheck.cpp
 

clang-tools-extra/clang-tidy/cert/NonTrivialTypesLibcMemoryCallsCheck.h

+//===--- NonTrivialTypesLibcMemoryCallsCheck.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_CERT_NONTRIVIALTYPESLIBCMEMORYCALLSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NONTRIVIALTYPESLIBCMEMORYCALLSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace cert {
+
+/// Flags use of the `C` standard library functions 'memset', 'memcpy' and
+/// 'memcmp' and similar derivatives on non-trivial types.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cert-oop57-cpp.html
+class NonTrivialTypesLibcMemoryCallsCheck : public ClangTidyCheck {
+public:
+  NonTrivialTypesLibcMemoryCallsCheck(StringRef Name,
+                                      ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const std::string MemSetNames;
+  const std::string MemCpyNames;
+  const std::string MemCmpNames;
+};
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NOTTRIVIALTYPESLIBCMEMORYCALLSCHECK_H

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

+//===--- NonTrivialTypesLibcMemoryCallsCheck.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 "NonTrivialTypesLibcMemoryCallsCheck.h"
+#include "../utils/OptionsUtils.h"
+#include "clang/AST/Decl.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/ASTMatchers/ASTMatchersInternal.h"
+#include "clang/ASTMatchers/ASTMatchersMacros.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace cert {
+
+namespace {
+AST_MATCHER(CXXRecordDecl, isTriviallyDefaultConstructible) {
+  return Node.hasTrivialDefaultConstructor();
+}
+AST_MATCHER(CXXRecordDecl, isTriviallyCopyable) {
+  return Node.hasTrivialCopyAssignment() && Node.hasTrivialCopyConstructor();
+}
+AST_MATCHER_P(NamedDecl, hasAnyNameStdString, std::vector<std::string>,
+              String) {
+  return ast_matchers::internal::HasNameMatcher(String).matchesNode(Node);
+}
+} // namespace
+
+static const char BuiltinMemSet[] = "::std::memset;"
+                                    "::memset;";
+static const char BuiltinMemCpy[] = "::std::memcpy;"
+                                    "::memcpy;"
+                                    "::std::memmove;"
+                                    "::memmove;"
+                                    "::std::strcpy;"
+                                    "::strcpy;"
+                                    "::memccpy;"
+                                    "::stpncpy;"
+                                    "::strncpy;";
+static const char BuiltinMemCmp[] = "::std::memcmp;"
+                                    "::memcmp;"
+                                    "::std::strcmp;"
+                                    "::strcmp;"
+                                    "::strncmp;";
+static constexpr llvm::StringRef ComparisonOperators[] = {
+    "operator==", "operator!=", "operator<",
+    "operator>",  "operator<=", "operator>="};
+
+static std::vector<std::string> parseStringListPair(StringRef LHS,
+                                                    StringRef RHS) {
+  if (LHS.empty()) {
+    if (RHS.empty())
+      return {};
+    return utils::options::parseStringList(RHS);
+  }
+  if (RHS.empty())
+    return utils::options::parseStringList(LHS);
+  llvm::SmallString<512> Buffer;
+  return utils::options::parseStringList((LHS + RHS).toStringRef(Buffer));
+}
+
+NonTrivialTypesLibcMemoryCallsCheck::NonTrivialTypesLibcMemoryCallsCheck(
+    StringRef Name, ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      MemSetNames(Options.get("MemSetNames", "")),
+      MemCpyNames(Options.get("MemCpyNames", "")),
+      MemCmpNames(Options.get("MemCmpNames", "")) {}
+
+void NonTrivialTypesLibcMemoryCallsCheck::storeOptions(
+    ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "MemSetNames", MemSetNames);
+  Options.store(Opts, "MemCpyNames", MemCpyNames);
+  Options.store(Opts, "MemCmpNames", MemCmpNames);
+}
+
+void NonTrivialTypesLibcMemoryCallsCheck::registerMatchers(
+    MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus || getLangOpts().ObjC)
+    return;
+
+  using namespace ast_matchers::internal;
+  auto IsStructPointer = [](Matcher<CXXRecordDecl> Constraint = anything(),
+                            bool Bind = false) {
+    return expr(unaryOperator(
+        hasOperatorName("&"),
+        hasUnaryOperand(declRefExpr(
+            allOf(hasType(cxxRecordDecl(Constraint)),
+                  hasType(Bind ? qualType().bind("Record") : qualType()))))));
+  };
+  auto IsRecordSizeOf =
+      expr(sizeOfExpr(hasArgumentOfType(equalsBoundNode("Record"))));
+  auto ArgChecker = [&](Matcher<CXXRecordDecl> RecordConstraint,
+                        BindableMatcher<Stmt> SecondArg) {
+    return allOf(argumentCountIs(3),
+                 hasArgument(0, IsStructPointer(RecordConstraint, true)),
+                 hasArgument(1, SecondArg), hasArgument(2, IsRecordSizeOf));
+  };
+
+  Finder->addMatcher(
+      callExpr(callee(namedDecl(hasAnyNameStdString(
+                   parseStringListPair(BuiltinMemSet, MemSetNames)))),
+               ArgChecker(unless(isTriviallyDefaultConstructible()),
+                          expr(integerLiteral(equals(0)))))
+          .bind("lazyConstruct"),
+      this);
+  Finder->addMatcher(
+      callExpr(callee(namedDecl(hasAnyNameStdString(
+                   parseStringListPair(BuiltinMemCpy, MemCpyNames)))),
+               ArgChecker(unless(isTriviallyCopyable()), IsStructPointer()))
+          .bind("lazyCopy"),
+      this);
+  Finder->addMatcher(
+      callExpr(callee(namedDecl(hasAnyNameStdString(
+                   parseStringListPair(BuiltinMemCmp, MemCmpNames)))),
+               ArgChecker(hasMethod(hasAnyName(ComparisonOperators)),
+                          IsStructPointer()))
+          .bind("lazyCompare"),
+      this);
+}
+
+void NonTrivialTypesLibcMemoryCallsCheck::check(
+    const MatchFinder::MatchResult &Result) {
+  if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyConstruct")) {
+    diag(Caller->getBeginLoc(), "calling %0 on a non-trivially default "
+                                "constructible class is undefined")
+        << cast<NamedDecl>(Caller->getCalleeDecl());
+  }
+  if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCopy")) {
+    diag(Caller->getBeginLoc(),
+         "calling %0 on a non-trivially copyable class is undefined")
+        << cast<NamedDecl>(Caller->getCalleeDecl());
+  }
+  if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCompare")) {
+    diag(Caller->getBeginLoc(),
+         "consider using comparison operators instead of calling %0")
+        << cast<NamedDecl>(Caller->getCalleeDecl());
+  }
+}
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
 New checks
 ^^^^^^^^^^
 
 - 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:`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 aliases
 ^^^^^^^^^^^
 
 - 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.
 

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

+.. title:: clang-tidy - cert-oop57-cpp
+
+cert-oop57-cpp
+==============
+
+  Flags use of the `C` standard library functions ``memset``, ``memcpy`` and
+  ``memcmp`` and similar derivatives on non-trivial types.
+
+Options
+-------
+
+.. option:: MemSetNames
+
+   Specify extra functions to flag that act similarily to ``memset``.
+   Specify names in a semicolon delimited list.
+   Default is an empty string.
+   The check will detect the following functions:
+   `memset`, `std::memset`.
+
+.. option:: MemCpyNames
+
+   Specify extra functions to flag that act similarily to ``memcpy``.
+   Specify names in a semicolon delimited list.
+   Default is an empty string.
+   The check will detect the following functions:
+   `std::memcpy`, `memcpy`, `std::memmove`, `memmove`, `std::strcpy`,
+   `strcpy`, `memccpy`, `stpncpy`, `strncpy`.
+
+.. option:: MemCmpNames
+
+   Specify extra functions to flag that act similarily to ``memcmp``.
+   Specify names in a semicolon delimited list.
+   Default is an empty string.
+   The check will detect the following functions:
+   `std::memcmp`, `memcmp`, `std::strcmp`, `strcmp`, `strncmp`.
+
+This check corresponds to the CERT C++ Coding Standard rule
+`OOP57-CPP. Prefer special member functions and overloaded operators to C 
+Standard Library functions
+<https://wiki.sei.cmu.edu/confluence/display/cplusplus/OOP57-CPP.+Prefer+special+member+functions+and+overloaded+operators+to+C+Standard+Library+functions>`_.

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

.. csv-table::
    `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>`_,
    `cert-msc51-cpp <cert-msc51-cpp.html>`_,
+   `cert-oop57-cpp <cert-oop57-cpp.html>`_,
    `cert-oop58-cpp <cert-oop58-cpp.html>`_,
    `clang-analyzer-core.DynamicTypePropagation <clang-analyzer-core.DynamicTypePropagation.html>`_,
    `clang-analyzer-core.uninitialized.CapturedBlockVariable <clang-analyzer-core.uninitialized.CapturedBlockVariable.html>`_,
    `clang-analyzer-cplusplus.InnerPointer <clang-analyzer-cplusplus.InnerPointer.html>`_,
    `clang-analyzer-nullability.NullableReturnedFromNonnull <clang-analyzer-nullability.NullableReturnedFromNonnull.html>`_,
    `clang-analyzer-optin.osx.OSObjectCStyleCast <clang-analyzer-optin.osx.OSObjectCStyleCast.html>`_,
    `clang-analyzer-optin.performance.GCDAntipattern <clang-analyzer-optin.performance.GCDAntipattern.html>`_,
    `clang-analyzer-optin.performance.Padding <clang-analyzer-optin.performance.Padding.html>`_,

clang-tools-extra/test/clang-tidy/checkers/cert-oop57-cpp.cpp

+// RUN: %check_clang_tidy %s cert-oop57-cpp %t -- \
+// RUN: -config='{CheckOptions: \
+// RUN:  [{key: cert-oop57-cpp.MemSetNames, value: mymemset}, \
+// RUN:  {key: cert-oop57-cpp.MemCpyNames, value: mymemcpy}, \
+// RUN:  {key: cert-oop57-cpp.MemCmpNames, value: mymemcmp}]}' \
+// RUN: --
+
+void mymemset(void *, unsigned char, decltype(sizeof(int)));
+void mymemcpy(void *, const void *, decltype(sizeof(int)));
+int mymemcmp(const void *, const void *, decltype(sizeof(int)));
+
+namespace std {
+void memset(void *, unsigned char, decltype(sizeof(int)));
+void memcpy(void *, const void *, decltype(sizeof(int)));
+void memmove(void *, const void *, decltype(sizeof(int)));
+void strcpy(void *, const void *, decltype(sizeof(int)));
+int memcmp(const void *, const void *, decltype(sizeof(int)));
+int strcmp(const void *, const void *, decltype(sizeof(int)));
+} // namespace std
+
+struct Trivial {
+  int I;
+  int J;
+};
+
+struct NonTrivial {
+  int I;
+  int J;
+
+  NonTrivial() : I(0), J(0) {}
+  NonTrivial &operator=(const NonTrivial &Other) {
+    I = Other.I;
+    J = Other.J;
+    return *this;
+  }
+
+  bool operator==(const Trivial &Other) const {
+    return I == Other.I && J == Other.J;
+  }
+  bool operator!=(const Trivial &Other) const {
+    return !(*this == Other);
+  }
+};
+
+void foo(const Trivial &Other) {
+  Trivial Data;
+  std::memset(&Data, 0, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: calling 'memset' on a non-trivially default constructible class is undefined
+  std::memset(&Data, 0, sizeof(Trivial));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: calling 'memset' on a non-trivially default constructible class is undefined
+  std::memcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: calling 'memcpy' on a non-trivially copyable class is undefined
+  std::memmove(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: calling 'memmove' on a non-trivially copyable class is undefined
+  std::strcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: calling 'strcpy' on a non-trivially copyable class is undefined
+  std::memcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'memcmp'
+  std::strcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'strcmp'
+}
+
+void bar(const NonTrivial &Other) {
+  NonTrivial Data;
+  std::memset(&Data, 0, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'memset' on a non-trivially default constructible class is undefined
+  // Check it detects sizeof(Type) as well as sizeof(Instantiation)
+  std::memset(&Data, 0, sizeof(NonTrivial));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'memset' on a non-trivially default constructible class is undefined
+  std::memcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'memcpy' on a non-trivially copyable class is undefined
+  std::memmove(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'memmove' on a non-trivially copyable class is undefined
+  std::strcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'strcpy' on a non-trivially copyable class is undefined
+  std::memcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'memcmp'
+  std::strcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'strcmp'
+}
+
+void baz(const NonTrivial &Other) {
+  NonTrivial Data;
+  mymemset(&Data, 0, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'mymemset' on a non-trivially default constructible class is undefined
+  mymemcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: calling 'mymemcpy' on a non-trivially copyable class is undefined
+  mymemcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'mymemcmp'
+}