[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

Please add check for C++.

clang-tools-extra/docs/ReleaseNotes.rst

70

Is this relevant?

114

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

115

Please remove This check. Same in documentation.

[njames93]

Tweaked a few documentation issues

[Eugene.Zelenko]

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

76

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

34–45

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)

46

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

56–58

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.

76

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.

103

This can be lowered into its only use.

127

Calling -> calling
non trivially -> non-trivially

(Same comments apply to the other diagnostics.)

129

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

19

c -> C

24

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

34–45

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

76

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

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

24

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

115

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

71–74 ↗

(On Diff #238153)

I'd combine these into a single if.

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

25 ↗

(On Diff #238153)

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

26

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 "NotTrivialTypesLibcMemoryCallsCheck.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<NotTrivialTypesLibcMemoryCallsCheck>(
+        "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
+  NotTrivialTypesLibcMemoryCallsCheck.cpp
   PostfixOperatorCheck.cpp
   ProperlySeededRandomGeneratorCheck.cpp
   SetLongJmpCheck.cpp
   StaticObjectExceptionCheck.cpp
   StrToNumCheck.cpp
   ThrownExceptionTypeCheck.cpp
   VariadicFunctionDefCheck.cpp
 

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

+//===--- NotTrivialTypesLibcMemoryCallsCheck.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_NOTTRIVIALTYPESLIBCMEMORYCALLSCHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NOTTRIVIALTYPESLIBCMEMORYCALLSCHECK_H
+
+#include "../ClangTidyCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace cert {
+
+/// This check flags use of the c standard library functions 'memset', 'memcpy',
+/// 'memmove', 'strcpy', 'memcmp' and 'strcmp' on non trivial types.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/cert-oop57-cpp.html
+class NotTrivialTypesLibcMemoryCallsCheck : public ClangTidyCheck {
+public:
+  NotTrivialTypesLibcMemoryCallsCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+};
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_NOTTRIVIALTYPESLIBCMEMORYCALLSCHECK_H

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

+//===--- NotTrivialTypesLibcMemoryCallsCheck.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 "NotTrivialTypesLibcMemoryCallsCheck.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.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();
+}
+} // namespace
+
+static constexpr llvm::StringRef LazyConstruct[] = {"::std::memset",
+                                                    "::memset"};
+static constexpr llvm::StringRef LazyCopy[] = {"::std::memcpy", "::memcpy",
+                                               "std::memmove",  "::memmove",
+                                               "::std::strcpy", "::strcpy"};
+static constexpr llvm::StringRef LazyCompare[] = {"::std::memcmp", "::memcmp",
+                                                  "std::strcmp", "::strcmp"};
+static constexpr llvm::StringRef EqualityComparison[] = {"operator==",
+                                                         "operator!="};
+
+static std::string getName(const CallExpr &Caller) {
+  llvm::SmallVector<char, 64> Buffer;
+  llvm::raw_svector_ostream OS(Buffer);
+  cast<NamedDecl>(Caller.getCalleeDecl())->printQualifiedName(OS);
+  return OS.str().trim(':');
+}
+
+void NotTrivialTypesLibcMemoryCallsCheck::registerMatchers(
+    MatchFinder *Finder) {
+  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 HasCxxRecordArgs = [&](Matcher<CXXRecordDecl> RecordConstraint,
+                              BindableMatcher<Stmt> SecondArg) {
+    return allOf(argumentCountIs(3),
+                 hasArgument(0, IsStructPointer(RecordConstraint, true)),
+                 hasArgument(1, SecondArg), hasArgument(2, IsRecordSizeOf));
+  };
+
+  auto IsIntZero = expr(integerLiteral(equals(0)));
+
+  Finder->addMatcher(
+      callExpr(callee(namedDecl(hasAnyName(LazyConstruct))),
+               HasCxxRecordArgs(unless(isTriviallyDefaultConstructible()),
+                                IsIntZero))
+          .bind("lazyConstruct"),
+      this);
+  Finder->addMatcher(callExpr(callee(namedDecl(hasAnyName(LazyCopy))),
+                              HasCxxRecordArgs(unless(isTriviallyCopyable()),
+                                               IsStructPointer()))
+                         .bind("lazyCopy"),
+                     this);
+  Finder->addMatcher(
+      callExpr(callee(namedDecl(hasAnyName(LazyCompare))),
+               HasCxxRecordArgs(hasMethod(hasAnyName(EqualityComparison)),
+                                IsStructPointer()))
+          .bind("lazyCompare"),
+      this);
+}
+
+void NotTrivialTypesLibcMemoryCallsCheck::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")
+        << getName(*Caller);
+  }
+  if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCopy")) {
+    diag(Caller->getBeginLoc(),
+         "Calling '%0' on a non trivially copyable class is undefined")
+        << getName(*Caller);
+  }
+  if (const auto *Caller = Result.Nodes.getNodeAs<CallExpr>("lazyCompare")) {
+    diag(Caller->getBeginLoc(),
+         "consider using comparison operators instead of calling '%0'")
+        << getName(*Caller);
+  }
+}
+
+} // namespace cert
+} // namespace tidy
+} // namespace clang

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- The 'bugprone-suspicous-constructor-and-assignment' check was renamed to :doc:`cert-not-trivial-types-libc-memory-calls
+  <clang-tidy/checks/cert-not-trivial-types-libc-memory-calls>`
+
 - New :doc:`bugprone-bad-signal-to-kill-thread
   <clang-tidy/checks/bugprone-bad-signal-to-kill-thread>` check.
 
   Finds ``pthread_kill`` function calls when a thread is terminated by 
   raising ``SIGTERM`` signal.
 
 - New :doc:`bugprone-dynamic-static-initializers
   <clang-tidy/checks/bugprone-dynamic-static-initializers>` check.
- New :doc:`bugprone-signed-char-misuse
   error.
 
 - New :doc:`cert-mem57-cpp
   <clang-tidy/checks/cert-mem57-cpp>` check.
 
   Checks if an object of type with extended alignment is allocated by using
   the default ``operator new``.
 
+- New :doc:`cert-oop57-cpp
+  <clang-tidy/checks/cert-oop57-cpp>` check.
+  Checks for calls to memset, memcpy, memmove, strcpy, memcmp and strcmp on non
+  trivial types.
+
 - New alias :doc:`cert-pos44-c
   <clang-tidy/checks/cert-pos44-c>` to
   :doc:`bugprone-bad-signal-to-kill-thread
   <clang-tidy/checks/bugprone-bad-signal-to-kill-thread>` was added.
 
 - New :doc:`cert-oop58-cpp
   <clang-tidy/checks/cert-oop58-cpp>` check.
 

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

+.. title:: clang-tidy - cert-oop57-cpp
+
+cert-oop57-cpp
+==============
+
+This check flags use of the c standard library functions 'memset', 'memcpy',
+'memmove', 'strcpy', 'memcmp' and 'strcmp' on non trivial types.
+
+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
+
+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 'std::memset' on a non trivially default constructible class is undefined
+  std::memset(&Data, 0, sizeof(Trivial));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: Calling 'std::memset' on a non trivially default constructible class is undefined
+  std::memcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: Calling 'std::memcpy' on a non trivially copyable class is undefined
+  std::memmove(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: Calling 'std::memmove' on a non trivially copyable class is undefined
+  std::strcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: Calling 'std::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 'std::memcmp'
+  std::strcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'std::strcmp'
+}
+
+void bar(const NonTrivial &Other) {
+  NonTrivial Data;
+  std::memset(&Data, 0, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Calling 'std::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 'std::memset' on a non trivially default constructible class is undefined
+  std::memcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Calling 'std::memcpy' on a non trivially copyable class is undefined
+  std::memmove(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Calling 'std::memmove' on a non trivially copyable class is undefined
+  std::strcpy(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: Calling 'std::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 'std::memcmp'
+  std::strcmp(&Data, &Other, sizeof(Data));
+  // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: consider using comparison operators instead of calling 'std::strcmp'
+}