[asan] Get rid of UB in unit tests for strstr, strcasestr, strspn, strcspn and strpbrk interceptors.

[m.ostapenko]

Summary

Following Eugeniy's suggestion in http://reviews.llvm.org/D10336, we can remove UB from tests for strstr, strcasestr, strspn, strcspn and strpbrk interceptors by extending corresponding string an poison it's tail manually.

Tested on x86_64-linux-gnu.
How does it look?

[eugenis]

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #37877)

This check could be made more strict now, right?
It should be always "s1" and always "overflows".

[m.ostapenko]

Addressing Eugeniy's nit. Make checks in tests more strict.

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #37991)

Indeed, thanks. I'll update corresponding tests to use more strict checks.

[eugenis]

It also looks like "s3" is now unused in all tests.
LGTM when that's fixed.

[m.ostapenko]

Thanks, attaching the patch to be committed.

compiler-rt/trunk/test/asan/TestCases/strcasestr-1.c

 // Test haystack overflow in strcasestr function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strstr asan option
 // Disable other interceptors because strlen may be called inside strcasestr
 // RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
 
 // There's no interceptor for strcasestr on Windows
 // XFAIL: win32
 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
-  char s1[] = {'a', 'C'};
-  char s3 = 0;
+  char s1[4] = "abC";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strcasestr(s1, s2);
-  // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == s1 + 1);
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
+  assert(r == s1 + 2);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcasestr-2.c

 // Test needle overflow in strcasestr function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strstr asan option
 // Disable other interceptors because strlen may be called inside strcasestr
 // RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
 
 // There's no interceptor for strcasestr on Windows
 // XFAIL: win32
 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s1[] = "ab";
-  char s2[] = {'c'};
-  char s3 = 0;
+  char s2[4] = "cba";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strcasestr(s1, s2);
   assert(r == 0);
-  // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcspn-1.c

 // Test string s1 overflow in strcspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
-  char s1[] = {'c', 'a'};
-  char s3 = 0;
+  char s1[4] = "caB";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strcspn(s1, s2);
-  // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strcspn-2.c

 // Test stopset overflow in strcspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strcspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s1[] = "ab";
-  char s2[] = {'a'};
-  char s3 = 0;
+  char s2[4] = "abc";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strcspn(s1, s2);
-  // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 0);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strpbrk-1.c

 // Test string s1 overflow in strpbrk function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r;
   char s2[] = "ab";
-  char s1[] = {'c', 'a'};
-  char s3 = 0;
+  char s1[4] = "cab";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strpbrk(s1, s2);
-  // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1 + 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strpbrk-2.c

 // Test stopset overflow in strpbrk function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: %env_asan_opts=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r;
   char s1[] = "c";
-  char s2[] = {'b', 'c'};
-  char s3 = 0;
+  char s2[4] = "bca";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strpbrk(s1, s2);
-  // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strspn-1.c

 // Test string s1 overflow in strspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
-  char s1[] = {'a', 'c'};
-  char s3 = 0;
+  char s1[4] = "acb";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strspn(s1, s2);
-  // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strspn-2.c

 // Test stopset overflow in strspn function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: %env_asan_opts=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s1[] = "bbc";
-  char s2[] = {'a', 'b'};
-  char s3 = 0;
+  char s2[5] = "abcd";
+  __asan_poison_memory_region ((char *)&s2[3], 2);
   r = strspn(s1, s2);
-  // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r >= 2);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strstr-1.c

 // Test haystack overflow in strstr function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strstr asan option
 // Disable other interceptors because strlen may be called inside strstr
 // RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
-  char s1[] = {'a', 'c'};
-  char s3 = 0;
+  char s1[4] = "acb";
+  __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strstr(s1, s2);
-  // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s1' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1 + 1);
   return 0;
 }

compiler-rt/trunk/test/asan/TestCases/strstr-2.c

 // Test needle overflow in strstr function
 // RUN: %clang_asan %s -o %t && %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strstr asan option
 // Disable other interceptors because strlen may be called inside strstr
 // RUN: %env_asan_opts=intercept_strstr=false:replace_str=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
+#include <sanitizer/asan_interface.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s1[] = "ab";
-  char s2[] = {'c'};
-  char s3 = 0;
+  char s2[4] = "cab";
+  __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strstr(s1, s2);
-  // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
+  // CHECK:'s2' <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == 0);
   return 0;
 }