Index: include/clang/AST/NonTrivialTypeVisitor.h
===================================================================
--- /dev/null
+++ include/clang/AST/NonTrivialTypeVisitor.h
@@ -0,0 +1,113 @@
+//===-- NonTrivialTypeVisitor.h - Visitor for non-trivial Types *- C++ --*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  This file defines the visitor classes that are used to traverse non-trivial
+//  structs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_NON_TRIVIAL_TYPE_VISITOR_H
+#define LLVM_CLANG_NON_TRIVIAL_TYPE_VISITOR_H
+
+#include "clang/AST/Type.h"
+
+namespace clang {
+
+template <class Derived, class RetTy = void> struct DestructedTypeVisitor {
+  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
+    return asDerived().visitWithKind(FT.isDestructedType(), FT,
+                                     std::forward<Ts>(Args)...);
+  }
+
+  template <class... Ts>
+  RetTy visitWithKind(QualType::DestructionKind DK, QualType FT,
+                      Ts &&... Args) {
+    switch (DK) {
+    case QualType::DK_objc_strong_lifetime:
+      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
+    case QualType::DK_nontrivial_c_struct:
+      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
+    case QualType::DK_none:
+      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
+    case QualType::DK_cxx_destructor:
+      return asDerived().visitCXXDestructor(FT, std::forward<Ts>(Args)...);
+    case QualType::DK_objc_weak_lifetime:
+      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
+    }
+
+    llvm_unreachable("unknown destruction kind");
+  }
+
+  Derived &asDerived() { return static_cast<Derived &>(*this); }
+};
+
+template <class Derived, class RetTy = void>
+struct DefaultInitializedTypeVisitor {
+  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
+    return asDerived().visitWithKind(
+        FT.isNonTrivialToPrimitiveDefaultInitialize(), FT,
+        std::forward<Ts>(Args)...);
+  }
+
+  template <class... Ts>
+  RetTy visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK,
+                      QualType FT, Ts &&... Args) {
+    switch (PDIK) {
+    case QualType::PDIK_ARCStrong:
+      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
+    case QualType::PDIK_ARCWeak:
+      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
+    case QualType::PDIK_Struct:
+      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
+    case QualType::PDIK_Trivial:
+      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
+    }
+
+    llvm_unreachable("unknown default-initialize kind");
+  }
+
+  Derived &asDerived() { return static_cast<Derived &>(*this); }
+};
+
+template <class Derived, bool IsMove, class RetTy = void>
+struct CopiedTypeVisitor {
+  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
+    QualType::PrimitiveCopyKind PCK =
+        IsMove ? FT.isNonTrivialToPrimitiveDestructiveMove()
+               : FT.isNonTrivialToPrimitiveCopy();
+    return asDerived().visitWithKind(PCK, FT, std::forward<Ts>(Args)...);
+  }
+
+  template <class... Ts>
+  RetTy visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT,
+                      Ts &&... Args) {
+    asDerived().preVisit(PCK, FT, std::forward<Ts>(Args)...);
+
+    switch (PCK) {
+    case QualType::PCK_ARCStrong:
+      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
+    case QualType::PCK_ARCWeak:
+      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
+    case QualType::PCK_Struct:
+      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
+    case QualType::PCK_Trivial:
+      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
+    case QualType::PCK_VolatileTrivial:
+      return asDerived().visitVolatileTrivial(FT, std::forward<Ts>(Args)...);
+    }
+
+    llvm_unreachable("unknown primitive copy kind");
+  }
+
+  Derived &asDerived() { return static_cast<Derived &>(*this); }
+};
+
+} // end namespace clang
+
+#endif
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td
+++ include/clang/Basic/DiagnosticSemaKinds.td
@@ -612,6 +612,13 @@
             "'%2'">;
 def warn_builtin_unknown : Warning<"use of unknown builtin %0">,
   InGroup<ImplicitFunctionDeclare>, DefaultError;
+def warn_cstruct_memaccess : Warning<
+  "%select{destination for|source of|first operand of|second operand of}0 this "
+  "%1 call is a pointer to record %2 that is not trivial to "
+  "%select{primitive-default-initialize|primitive-copy}3">,
+  InGroup<DiagGroup<"nontrivial-memaccess">>;
+def note_nontrivial_field : Note<
+  "field is non-trivial to %select{copy|default-initialize}0">;
 def warn_dyn_class_memaccess : Warning<
   "%select{destination for|source of|first operand of|second operand of}0 this "
   "%1 call is a pointer to %select{|class containing a }2dynamic class %3; "
Index: lib/CodeGen/CGNonTrivialStruct.cpp
===================================================================
--- lib/CodeGen/CGNonTrivialStruct.cpp
+++ lib/CodeGen/CGNonTrivialStruct.cpp
@@ -14,6 +14,7 @@
 
 #include "CodeGenFunction.h"
 #include "CodeGenModule.h"
+#include "clang/AST/NonTrivialTypeVisitor.h"
 #include "llvm/Support/ScopedPrinter.h"
 #include <array>
 
@@ -32,101 +33,6 @@
 enum { DstIdx = 0, SrcIdx = 1 };
 const char *ValNameStr[2] = {"dst", "src"};
 
-template <class Derived, class RetTy = void> struct DestructedTypeVisitor {
-  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
-    return asDerived().visit(FT.isDestructedType(), FT,
-                             std::forward<Ts>(Args)...);
-  }
-
-  template <class... Ts>
-  RetTy visit(QualType::DestructionKind DK, QualType FT, Ts &&... Args) {
-    if (asDerived().getContext().getAsArrayType(FT))
-      return asDerived().visitArray(DK, FT, std::forward<Ts>(Args)...);
-
-    switch (DK) {
-    case QualType::DK_objc_strong_lifetime:
-      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
-    case QualType::DK_nontrivial_c_struct:
-      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
-    case QualType::DK_none:
-      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
-    case QualType::DK_cxx_destructor:
-      return asDerived().visitCXXDestructor(FT, std::forward<Ts>(Args)...);
-    case QualType::DK_objc_weak_lifetime:
-      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
-    }
-
-    llvm_unreachable("unknown destruction kind");
-  }
-
-  Derived &asDerived() { return static_cast<Derived &>(*this); }
-};
-
-template <class Derived, class RetTy = void>
-struct DefaultInitializedTypeVisitor {
-  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
-    return asDerived().visit(FT.isNonTrivialToPrimitiveDefaultInitialize(), FT,
-                             std::forward<Ts>(Args)...);
-  }
-
-  template <class... Ts>
-  RetTy visit(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
-              Ts &&... Args) {
-    if (asDerived().getContext().getAsArrayType(FT))
-      return asDerived().visitArray(PDIK, FT, std::forward<Ts>(Args)...);
-
-    switch (PDIK) {
-    case QualType::PDIK_ARCStrong:
-      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
-    case QualType::PDIK_ARCWeak:
-      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
-    case QualType::PDIK_Struct:
-      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
-    case QualType::PDIK_Trivial:
-      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
-    }
-
-    llvm_unreachable("unknown default-initialize kind");
-  }
-
-  Derived &asDerived() { return static_cast<Derived &>(*this); }
-};
-
-template <class Derived, bool IsMove, class RetTy = void>
-struct CopiedTypeVisitor {
-  template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
-    QualType::PrimitiveCopyKind PCK =
-        IsMove ? FT.isNonTrivialToPrimitiveDestructiveMove()
-               : FT.isNonTrivialToPrimitiveCopy();
-    return asDerived().visit(PCK, FT, std::forward<Ts>(Args)...);
-  }
-
-  template <class... Ts>
-  RetTy visit(QualType::PrimitiveCopyKind PCK, QualType FT, Ts &&... Args) {
-    asDerived().preVisit(PCK, FT, std::forward<Ts>(Args)...);
-
-    if (asDerived().getContext().getAsArrayType(FT))
-      return asDerived().visitArray(PCK, FT, std::forward<Ts>(Args)...);
-
-    switch (PCK) {
-    case QualType::PCK_ARCStrong:
-      return asDerived().visitARCStrong(FT, std::forward<Ts>(Args)...);
-    case QualType::PCK_ARCWeak:
-      return asDerived().visitARCWeak(FT, std::forward<Ts>(Args)...);
-    case QualType::PCK_Struct:
-      return asDerived().visitStruct(FT, std::forward<Ts>(Args)...);
-    case QualType::PCK_Trivial:
-      return asDerived().visitTrivial(FT, std::forward<Ts>(Args)...);
-    case QualType::PCK_VolatileTrivial:
-      return asDerived().visitVolatileTrivial(FT, std::forward<Ts>(Args)...);
-    }
-
-    llvm_unreachable("unknown primitive copy kind");
-  }
-
-  Derived &asDerived() { return static_cast<Derived &>(*this); }
-};
-
 template <class Derived> struct StructVisitor {
   StructVisitor(ASTContext &Ctx) : Ctx(Ctx) {}
 
@@ -172,6 +78,7 @@
 struct CopyStructVisitor : StructVisitor<Derived>,
                            CopiedTypeVisitor<Derived, IsMove> {
   using StructVisitor<Derived>::asDerived;
+  using Super = CopiedTypeVisitor<Derived, IsMove>;
 
   CopyStructVisitor(ASTContext &Ctx) : StructVisitor<Derived>(Ctx) {}
 
@@ -183,6 +90,20 @@
       asDerived().flushTrivialFields(std::forward<Ts>(Args)...);
   }
 
+  template <class... Ts>
+  void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT,
+                     const FieldDecl *FD, CharUnits CurStructOffsset,
+                     Ts &&... Args) {
+    if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
+      asDerived().visitArray(PCK, AT, FT.isVolatileQualified(), FD,
+                             CurStructOffsset, std::forward<Ts>(Args)...);
+      return;
+    }
+
+    Super::visitWithKind(PCK, FT, FD, CurStructOffsset,
+                         std::forward<Ts>(Args)...);
+  }
+
   template <class... Ts>
   void visitTrivial(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
                     Ts... Args) {
@@ -259,24 +180,24 @@
   }
 
   template <class FieldKind>
-  void visitArray(FieldKind FK, QualType QT, const FieldDecl *FD,
-                  CharUnits CurStructOffset) {
+  void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
+                  const FieldDecl *FD, CharUnits CurStructOffset) {
     // String for non-volatile trivial fields is emitted when
     // flushTrivialFields is called.
     if (!FK)
-      return asDerived().visitTrivial(QT, FD, CurStructOffset);
+      return asDerived().visitTrivial(QualType(AT, 0), FD, CurStructOffset);
 
     CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
     ASTContext &Ctx = asDerived().getContext();
-    const auto *AT = Ctx.getAsConstantArrayType(QT);
-    unsigned NumElts = Ctx.getConstantArrayElementCount(AT);
-    QualType EltTy = Ctx.getBaseElementType(AT);
+    const ConstantArrayType *CAT = cast<ConstantArrayType>(AT);
+    unsigned NumElts = Ctx.getConstantArrayElementCount(CAT);
+    QualType EltTy = Ctx.getBaseElementType(CAT);
     CharUnits EltSize = Ctx.getTypeSizeInChars(EltTy);
     appendStr("_AB" + llvm::to_string(FieldOffset.getQuantity()) + "s" +
               llvm::to_string(EltSize.getQuantity()) + "n" +
               llvm::to_string(NumElts));
-    EltTy = QT.isVolatileQualified() ? EltTy.withVolatile() : EltTy;
-    asDerived().visit(FK, EltTy, nullptr, FieldOffset);
+    EltTy = IsVolatile ? EltTy.withVolatile() : EltTy;
+    asDerived().visitWithKind(FK, EltTy, nullptr, FieldOffset);
     appendStr("_AE");
   }
 
@@ -344,16 +265,36 @@
 struct GenDefaultInitializeFuncName
     : GenUnaryFuncName<GenDefaultInitializeFuncName>,
       DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName> {
+  using Super = DefaultInitializedTypeVisitor<GenDefaultInitializeFuncName>;
   GenDefaultInitializeFuncName(CharUnits DstAlignment, ASTContext &Ctx)
       : GenUnaryFuncName<GenDefaultInitializeFuncName>("__default_constructor_",
                                                        DstAlignment, Ctx) {}
+  void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
+                     const FieldDecl *FD, CharUnits CurStructOffset) {
+    if (const auto *AT = getContext().getAsArrayType(FT)) {
+      visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset);
+      return;
+    }
+
+    Super::visitWithKind(PDIK, FT, FD, CurStructOffset);
+  }
 };
 
 struct GenDestructorFuncName : GenUnaryFuncName<GenDestructorFuncName>,
                                DestructedTypeVisitor<GenDestructorFuncName> {
+  using Super = DestructedTypeVisitor<GenDestructorFuncName>;
   GenDestructorFuncName(CharUnits DstAlignment, ASTContext &Ctx)
       : GenUnaryFuncName<GenDestructorFuncName>("__destructor_", DstAlignment,
                                                 Ctx) {}
+  void visitWithKind(QualType::DestructionKind DK, QualType FT,
+                     const FieldDecl *FD, CharUnits CurStructOffset) {
+    if (const auto *AT = getContext().getAsArrayType(FT)) {
+      visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset);
+      return;
+    }
+
+    Super::visitWithKind(DK, FT, FD, CurStructOffset);
+  }
 };
 
 // Helper function that creates CGFunctionInfo for an N-ary special function.
@@ -386,11 +327,13 @@
   }
 
   template <class FieldKind, size_t N>
-  void visitArray(FieldKind FK, QualType QT, const FieldDecl *FD,
-                  CharUnits CurStackOffset, std::array<Address, N> Addrs) {
+  void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
+                  const FieldDecl *FD, CharUnits CurStackOffset,
+                  std::array<Address, N> Addrs) {
     // Non-volatile trivial fields are copied when flushTrivialFields is called.
     if (!FK)
-      return asDerived().visitTrivial(QT, FD, CurStackOffset, Addrs);
+      return asDerived().visitTrivial(QualType(AT, 0), FD, CurStackOffset,
+                                      Addrs);
 
     CodeGenFunction &CGF = *this->CGF;
     ASTContext &Ctx = CGF.getContext();
@@ -401,8 +344,7 @@
     for (unsigned I = 0; I < N; ++I)
       StartAddrs[I] = getAddrWithOffset(Addrs[I], CurStackOffset, FD);
     Address DstAddr = StartAddrs[DstIdx];
-    llvm::Value *NumElts =
-        CGF.emitArrayLength(Ctx.getAsArrayType(QT), BaseEltQT, DstAddr);
+    llvm::Value *NumElts = CGF.emitArrayLength(AT, BaseEltQT, DstAddr);
     unsigned BaseEltSize = Ctx.getTypeSizeInChars(BaseEltQT).getQuantity();
     llvm::Value *BaseEltSizeVal =
         llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);
@@ -437,7 +379,7 @@
 
     // Visit the element of the array in the loop body.
     CGF.EmitBlock(LoopBB);
-    QualType EltQT = Ctx.getAsArrayType(QT)->getElementType();
+    QualType EltQT = AT->getElementType();
     CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
     std::array<Address, N> NewAddrs = Addrs;
 
@@ -445,8 +387,9 @@
       NewAddrs[I] = Address(
           PHIs[I], StartAddrs[I].getAlignment().alignmentAtOffset(EltSize));
 
-    EltQT = QT.isVolatileQualified() ? EltQT.withVolatile() : EltQT;
-    this->asDerived().visit(EltQT, nullptr, CharUnits::Zero(), NewAddrs);
+    EltQT = IsVolatile ? EltQT.withVolatile() : EltQT;
+    this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
+                                    NewAddrs);
 
     LoopBB = CGF.Builder.GetInsertBlock();
 
@@ -624,7 +567,20 @@
 struct GenDestructor : StructVisitor<GenDestructor>,
                        GenFuncBase<GenDestructor>,
                        DestructedTypeVisitor<GenDestructor> {
+  using Super = DestructedTypeVisitor<GenDestructor>;
   GenDestructor(ASTContext &Ctx) : StructVisitor<GenDestructor>(Ctx) {}
+
+  void visitWithKind(QualType::DestructionKind DK, QualType FT,
+                     const FieldDecl *FD, CharUnits CurStructOffset,
+                     std::array<Address, 1> Addrs) {
+    if (const auto *AT = getContext().getAsArrayType(FT)) {
+      visitArray(DK, AT, FT.isVolatileQualified(), FD, CurStructOffset, Addrs);
+      return;
+    }
+
+    Super::visitWithKind(DK, FT, FD, CurStructOffset, Addrs);
+  }
+
   void visitARCStrong(QualType QT, const FieldDecl *FD,
                       CharUnits CurStackOffset, std::array<Address, 1> Addrs) {
     CGF->destroyARCStrongImprecise(
@@ -648,10 +604,24 @@
     : StructVisitor<GenDefaultInitialize>,
       GenFuncBase<GenDefaultInitialize>,
       DefaultInitializedTypeVisitor<GenDefaultInitialize> {
+  using Super = DefaultInitializedTypeVisitor<GenDefaultInitialize>;
   typedef GenFuncBase<GenDefaultInitialize> GenFuncBaseTy;
+
   GenDefaultInitialize(ASTContext &Ctx)
       : StructVisitor<GenDefaultInitialize>(Ctx) {}
 
+  void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
+                     const FieldDecl *FD, CharUnits CurStructOffset,
+                     std::array<Address, 1> Addrs) {
+    if (const auto *AT = getContext().getAsArrayType(FT)) {
+      visitArray(PDIK, AT, FT.isVolatileQualified(), FD, CurStructOffset,
+                 Addrs);
+      return;
+    }
+
+    Super::visitWithKind(PDIK, FT, FD, CurStructOffset, Addrs);
+  }
+
   void visitARCStrong(QualType QT, const FieldDecl *FD,
                       CharUnits CurStackOffset, std::array<Address, 1> Addrs) {
     CGF->EmitNullInitialization(
@@ -665,17 +635,18 @@
   }
 
   template <class FieldKind, size_t... Is>
-  void visitArray(FieldKind FK, QualType QT, const FieldDecl *FD,
-                  CharUnits CurStackOffset, std::array<Address, 1> Addrs) {
+  void visitArray(FieldKind FK, const ArrayType *AT, bool IsVolatile,
+                  const FieldDecl *FD, CharUnits CurStackOffset,
+                  std::array<Address, 1> Addrs) {
     if (!FK)
-      return visitTrivial(QT, FD, CurStackOffset, Addrs);
+      return visitTrivial(QualType(AT, 0), FD, CurStackOffset, Addrs);
 
     ASTContext &Ctx = getContext();
-    CharUnits Size = Ctx.getTypeSizeInChars(QT);
-    QualType EltTy = Ctx.getBaseElementType(QT);
+    CharUnits Size = Ctx.getTypeSizeInChars(QualType(AT, 0));
+    QualType EltTy = Ctx.getBaseElementType(QualType(AT, 0));
 
     if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
-      GenFuncBaseTy::visitArray(FK, QT, FD, CurStackOffset, Addrs);
+      GenFuncBaseTy::visitArray(FK, AT, IsVolatile, FD, CurStackOffset, Addrs);
       return;
     }
 
@@ -683,7 +654,7 @@
     Address DstAddr = getAddrWithOffset(Addrs[DstIdx], CurStackOffset, FD);
     Address Loc = CGF->Builder.CreateElementBitCast(DstAddr, CGF->Int8Ty);
     CGF->Builder.CreateMemSet(Loc, CGF->Builder.getInt8(0), SizeVal,
-                              QT.isVolatileQualified());
+                              IsVolatile);
   }
 
   void callSpecialFunction(QualType FT, CharUnits Offset,
Index: lib/Sema/SemaChecking.cpp
===================================================================
--- lib/Sema/SemaChecking.cpp
+++ lib/Sema/SemaChecking.cpp
@@ -28,6 +28,7 @@
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/NSAPI.h"
+#include "clang/AST/NonTrivialTypeVisitor.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
@@ -7378,6 +7379,98 @@
   return QualType();
 }
 
+namespace {
+
+struct SearchNonTrivialToInitializeField
+    : DefaultInitializedTypeVisitor<SearchNonTrivialToInitializeField> {
+  using Super =
+      DefaultInitializedTypeVisitor<SearchNonTrivialToInitializeField>;
+
+  SearchNonTrivialToInitializeField(const Expr *E, Sema &S) : E(E), S(S) {}
+
+  void visitWithKind(QualType::PrimitiveDefaultInitializeKind PDIK, QualType FT,
+                     SourceLocation SL) {
+    if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
+      asDerived().visitArray(PDIK, AT, SL);
+      return;
+    }
+
+    Super::visitWithKind(PDIK, FT, SL);
+  }
+
+  void visitARCStrong(QualType FT, SourceLocation SL) {
+    S.DiagRuntimeBehavior(SL, E, S.PDiag(diag::note_nontrivial_field) << 1);
+  }
+  void visitARCWeak(QualType FT, SourceLocation SL) {
+    S.DiagRuntimeBehavior(SL, E, S.PDiag(diag::note_nontrivial_field) << 1);
+  }
+  void visitStruct(QualType FT, SourceLocation SL) {
+    for (const FieldDecl *FD : FT->castAs<RecordType>()->getDecl()->fields())
+      visit(FD->getType(), FD->getLocation());
+  }
+  void visitArray(QualType::PrimitiveDefaultInitializeKind PDIK,
+                  const ArrayType *AT, SourceLocation SL) {
+    visit(getContext().getBaseElementType(AT), SL);
+  }
+  void visitTrivial(QualType FT, SourceLocation SL) {}
+
+  static void diag(QualType RT, const Expr *E, Sema &S) {
+    SearchNonTrivialToInitializeField(E, S).visitStruct(RT, SourceLocation());
+  }
+
+  ASTContext &getContext() { return S.getASTContext(); }
+
+  const Expr *E;
+  Sema &S;
+};
+
+struct SearchNonTrivialToCopyField
+    : CopiedTypeVisitor<SearchNonTrivialToCopyField, false> {
+  using Super = CopiedTypeVisitor<SearchNonTrivialToCopyField, false>;
+
+  SearchNonTrivialToCopyField(const Expr *E, Sema &S) : E(E), S(S) {}
+
+  void visitWithKind(QualType::PrimitiveCopyKind PCK, QualType FT,
+                     SourceLocation SL) {
+    if (const auto *AT = asDerived().getContext().getAsArrayType(FT)) {
+      asDerived().visitArray(PCK, AT, SL);
+      return;
+    }
+
+    Super::visitWithKind(PCK, FT, SL);
+  }
+
+  void visitARCStrong(QualType FT, SourceLocation SL) {
+    S.DiagRuntimeBehavior(SL, E, S.PDiag(diag::note_nontrivial_field) << 0);
+  }
+  void visitARCWeak(QualType FT, SourceLocation SL) {
+    S.DiagRuntimeBehavior(SL, E, S.PDiag(diag::note_nontrivial_field) << 0);
+  }
+  void visitStruct(QualType FT, SourceLocation SL) {
+    for (const FieldDecl *FD : FT->castAs<RecordType>()->getDecl()->fields())
+      visit(FD->getType(), FD->getLocation());
+  }
+  void visitArray(QualType::PrimitiveCopyKind PCK, const ArrayType *AT,
+                  SourceLocation SL) {
+    visit(getContext().getBaseElementType(AT), SL);
+  }
+  void preVisit(QualType::PrimitiveCopyKind PCK, QualType FT,
+                SourceLocation SL) {}
+  void visitTrivial(QualType FT, SourceLocation SL) {}
+  void visitVolatileTrivial(QualType FT, SourceLocation SL) {}
+
+  static void diag(QualType RT, const Expr *E, Sema &S) {
+    SearchNonTrivialToCopyField(E, S).visitStruct(RT, SourceLocation());
+  }
+
+  ASTContext &getContext() { return S.getASTContext(); }
+
+  const Expr *E;
+  Sema &S;
+};
+
+}
+
 /// \brief Check for dangerous or invalid arguments to memset().
 ///
 /// This issues warnings on known problematic, dangerous or unspecified
@@ -7543,7 +7636,23 @@
         PDiag(diag::warn_arc_object_memaccess)
           << ArgIdx << FnName << PointeeTy
           << Call->getCallee()->getSourceRange());
-    else
+    else if (const auto *RT = PointeeTy->getAs<RecordType>()) {
+      if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) &&
+          RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {
+          DiagRuntimeBehavior(Dest->getExprLoc(), Dest,
+                              PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName
+                                  << PointeeTy << 0);
+          SearchNonTrivialToInitializeField::diag(PointeeTy, Dest, *this);
+      } else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) &&
+                 RT->getDecl()->isNonTrivialToPrimitiveCopy()) {
+          DiagRuntimeBehavior(Dest->getExprLoc(), Dest,
+                              PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName
+                                  << PointeeTy << 1);
+          SearchNonTrivialToCopyField::diag(PointeeTy, Dest, *this);
+      } else {
+        continue;
+      }
+    } else
       continue;
 
     DiagRuntimeBehavior(
Index: test/SemaObjC/warn-nontrivial-struct-memaccess.m
===================================================================
--- /dev/null
+++ test/SemaObjC/warn-nontrivial-struct-memaccess.m
@@ -0,0 +1,39 @@
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fobjc-runtime-has-weak -x objective-c -fobjc-arc -verify %s
+
+void *memset(void *, int, __SIZE_TYPE__);
+void bzero(void *, __SIZE_TYPE__);
+void *memcpy(void *, const void *, __SIZE_TYPE__);
+void *memmove(void *, const void *, __SIZE_TYPE__);
+
+struct Trivial {
+  int f0;
+  volatile int f1;
+};
+
+struct NonTrivial0 {
+  int f0;
+  __weak id f1; // expected-note 2 {{non-trivial to default-initialize}} expected-note 2 {{non-trivial to copy}}
+  volatile int f2;
+  id f3[10]; // expected-note 2 {{non-trivial to default-initialize}} expected-note 2 {{non-trivial to copy}}
+};
+
+struct NonTrivial1 {
+  id f0; // expected-note 2 {{non-trivial to default-initialize}} expected-note 2 {{non-trivial to copy}}
+  int f1;
+  struct NonTrivial0 f2;
+};
+
+void testTrivial(struct Trivial *d, struct Trivial *s) {
+  memset(d, 0, sizeof(struct Trivial));
+  bzero(d, sizeof(struct Trivial));
+  memcpy(d, s, sizeof(struct Trivial));
+  memmove(d, s, sizeof(struct Trivial));
+}
+
+void testNonTrivial1(struct NonTrivial1 *d, struct NonTrivial1 *s) {
+  memset(d, 0, sizeof(struct NonTrivial1)); // expected-warning {{that is not trivial to primitive-default-initialize}} expected-note {{explicitly cast the pointer to silence}}
+  memset((void *)d, 0, sizeof(struct NonTrivial1));
+  bzero(d, sizeof(struct NonTrivial1)); // expected-warning {{that is not trivial to primitive-default-initialize}} expected-note {{explicitly cast the pointer to silence}}
+  memcpy(d, s, sizeof(struct NonTrivial1)); // expected-warning {{that is not trivial to primitive-copy}} expected-note {{explicitly cast the pointer to silence}}
+  memmove(d, s, sizeof(struct NonTrivial1)); // expected-warning {{that is not trivial to primitive-copy}} expected-note {{explicitly cast the pointer to silence}}
+}