Revert "[Sema] Add sizeof diagnostics for bzero"

This reverts commit r277787, which caused PR28870.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@277830 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
index 813a20a9f526ff24074fa2d1b6856f8d26fd91b5..d1e8d25ea044b804da40b431a6f8447031cf432f 100644 (file)
--- a/lib/AST/Decl.cpp
+++ b/lib/AST/Decl.cpp
@@ -3408,10 +3408,6 @@ unsigned FunctionDecl::getMemoryFunctionKind() const {
   case Builtin::BIstrlen:
     return Builtin::BIstrlen;
 
-  case Builtin::BI__builtin_bzero:
-  case Builtin::BIbzero:
-    return Builtin::BIbzero;
-
   default:
     if (isExternC()) {
       if (FnInfo->isStr("memset"))
@@ -3434,8 +3430,6 @@ unsigned FunctionDecl::getMemoryFunctionKind() const {
         return Builtin::BIstrndup;
       else if (FnInfo->isStr("strlen"))
         return Builtin::BIstrlen;
-      else if (FnInfo->isStr("bzero"))
-        return Builtin::BIbzero;
     }
     break;
   }

diff --git a/lib/Sema/SemaChecking.cpp b/lib/Sema/SemaChecking.cpp
index c7163943cfbc66370e1f7728aa2bcf6532644697..12f3923f8e114b66152e81efeba5e3e4fd9f32e8 100644 (file)
--- a/lib/Sema/SemaChecking.cpp
+++ b/lib/Sema/SemaChecking.cpp
@@ -6179,15 +6179,13 @@ void Sema::CheckMemaccessArguments(const CallExpr *Call,
 
   // It is possible to have a non-standard definition of memset.  Validate
   // we have enough arguments, and if not, abort further checking.
-  unsigned ExpectedNumArgs =
-      (BId == Builtin::BIstrndup || Builtin::BIbzero ? 2 : 3);
+  unsigned ExpectedNumArgs = (BId == Builtin::BIstrndup ? 2 : 3);
   if (Call->getNumArgs() < ExpectedNumArgs)
     return;
 
-  unsigned LastArg = (BId == Builtin::BImemset || BId == Builtin::BIbzero ||
+  unsigned LastArg = (BId == Builtin::BImemset ||
                       BId == Builtin::BIstrndup ? 1 : 2);
-  unsigned LenArg =
-      (BId == Builtin::BIbzero || BId == Builtin::BIstrndup ? 1 : 2);
+  unsigned LenArg = (BId == Builtin::BIstrndup ? 1 : 2);
   const Expr *LenExpr = Call->getArg(LenArg)->IgnoreParenImpCasts();
 
   if (CheckMemorySizeofForComparison(*this, LenExpr, FnName,

diff --git a/test/SemaCXX/warn-memset-bad-sizeof.cpp b/test/SemaCXX/warn-memset-bad-sizeof.cpp
index 0a78caa924ea95a1468f25bbb09066bb2e20d491..cca15fc8ef3cf90af1879826afbe180a1ecd6eeb 100644 (file)
--- a/test/SemaCXX/warn-memset-bad-sizeof.cpp
+++ b/test/SemaCXX/warn-memset-bad-sizeof.cpp
@@ -1,6 +1,5 @@
 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-sizeof-array-argument %s
 //
-extern "C" void *bzero(void *, unsigned);
 extern "C" void *memset(void *, int, unsigned);
 extern "C" void *memmove(void *s1, const void *s2, unsigned n);
 extern "C" void *memcpy(void *s1, const void *s2, unsigned n);
@@ -48,19 +47,6 @@ void f(Mat m, const Foo& const_foo, char *buffer) {
   memset(heap_buffer, 0, sizeof(heap_buffer));  // \
       // expected-warning {{'memset' call operates on objects of type 'char' while the size is based on a different type 'char *'}} expected-note{{did you mean to provide an explicit length?}}
 
-  bzero(&s, sizeof(&s));  // \
-      // expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
-  bzero(ps, sizeof(ps));  // \
-      // expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
-  bzero(ps2, sizeof(ps2));  // \
-      // expected-warning {{'bzero' call operates on objects of type 'S' while the size is based on a different type 'PS' (aka 'S *')}} expected-note{{did you mean to dereference the argument to 'sizeof' (and multiply it by the number of elements)?}}
-  bzero(ps2, sizeof(typeof(ps2)));  // \
-      // expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
-  bzero(ps2, sizeof(PS));  // \
-      // expected-warning {{argument to 'sizeof' in 'bzero' call is the same pointer type}}
-  bzero(heap_buffer, sizeof(heap_buffer));  // \
-      // expected-warning {{'bzero' call operates on objects of type 'char' while the size is based on a different type 'char *'}} expected-note{{did you mean to provide an explicit length?}}
-
   memcpy(&s, 0, sizeof(&s));  // \
       // expected-warning {{'memcpy' call operates on objects of type 'S' while the size is based on a different type 'S *'}} expected-note{{did you mean to remove the addressof in the argument to 'sizeof' (and multiply it by the number of elements)?}}
   memcpy(0, &s, sizeof(&s));  // \
@@ -87,21 +73,6 @@ void f(Mat m, const Foo& const_foo, char *buffer) {
   memset(arr, 0, sizeof(arr));
   memset(parr, 0, sizeof(parr));
 
-  bzero((void*)&s, sizeof(&s));
-  bzero(&s, sizeof(s));
-  bzero(&s, sizeof(S));
-  bzero(&s, sizeof(const S));
-  bzero(&s, sizeof(volatile S));
-  bzero(&s, sizeof(volatile const S));
-  bzero(&foo, sizeof(CFoo));
-  bzero(&foo, sizeof(VFoo));
-  bzero(&foo, sizeof(CVFoo));
-  bzero(ps, sizeof(*ps));
-  bzero(ps2, sizeof(*ps2));
-  bzero(ps2, sizeof(typeof(*ps2)));
-  bzero(arr, sizeof(arr));
-  bzero(parr, sizeof(parr));
-
   memcpy(&foo, &const_foo, sizeof(Foo));
   memcpy((void*)&s, 0, sizeof(&s));
   memcpy(0, (void*)&s, sizeof(&s));
@@ -125,17 +96,12 @@ void f(Mat m, const Foo& const_foo, char *buffer) {
   int iarr[14];
   memset(&iarr[0], 0, sizeof iarr);
   memset(iarr, 0, sizeof iarr);
-  bzero(&iarr[0], sizeof iarr);
-  bzero(iarr, sizeof iarr);
 
   int* iparr[14];
   memset(&iparr[0], 0, sizeof iparr);
   memset(iparr, 0, sizeof iparr);
-  bzero(&iparr[0], sizeof iparr);
-  bzero(iparr, sizeof iparr);
 
   memset(m, 0, sizeof(Mat));
-  bzero(m, sizeof(Mat));
 
   // Copy to raw buffer shouldn't warn either
   memcpy(&foo, &arr, sizeof(Foo));
@@ -148,21 +114,12 @@ void f(Mat m, const Foo& const_foo, char *buffer) {
     for (;;) {}
     &s;
   }), 0, sizeof(s));
-
-  bzero(({
-    if (0) {}
-    while (0) {}
-    for (;;) {}
-    &s;
-  }), sizeof(s));
 }
 
 namespace ns {
 void memset(void* s, char c, int n);
-void bzero(void* s, int n);
 void f(int* i) {
   memset(i, 0, sizeof(i));
-  bzero(i, sizeof(i));
 }
 }