Fix tests for new str interceptors

[m.guseva]

Summary

Due to recent fail of strcspn-2 (http://lab.llvm.org:8011/builders/sanitizer-ppc64-linux1/builds/7321/steps/check-asan%20in%20gcc%20build/logs/stdio) I've modified recently added unit tests for str interceptors to be more deterministic.

[eugenis]

OI would be great if someone investigated the "s3" point in my other comment, but this change alone should make the tests much more stable, so LGTM.

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #27365)

I missed the original code review, but this "s3" business looks highly suspicious. Firstly, it is not good to rely on the order of variable declarations in the function body, compiler definitely does not promise anything about that. Secondly, if ASan may say that access overflows s3 - I'd treat this as a bug in the tool. Why does it happen? COMMON_INTERCEPTOR_READ_* should point to the first poisoned byte in the memory range, which should be the first byte after the end of s1.

[ygribov]

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #27365)

I think we do need to put stopping zero byte somehow to ensure that e.g. underlying Glibc's strcasestr always terminates. Any suggestions how to achieve this in a cleaner way? Perhaps set last byte of s1's redzone to 0 in a noinline no_sanitize_address helper function?

Overflow in s3 is strange indeed.

[eugenis]

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #27365)

Maybe just allocate a larger buffer for the string and __asan_poison part of it. The report would just say "wild address" though, without a reference to s1/s2 variables.

[ygribov]

test/asan/TestCases/strcasestr-1.c

21 ↗

(On Diff #27365)

Ah, right. Mash is on vacation so I guess I'll commit what we have meanwhile.

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

 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
-  char s1[] = {'a', 'b'};
+  char s1[] = {'a', 'C'};
   char s3 = 0;
   r = strcasestr(s1, s2);
   // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == 0);
+  assert(r == s1 + 1);
   return 0;
 }

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

 // Test string s1 overflow in strcspn function
 // RUN: %clang_asan %s -o %t && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
-  char s1[] = {'c', 'd'};
+  char s1[] = {'c', 'a'};
   char s3 = 0;
   r = strcspn(s1, s2);
   // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r >= sizeof(s1));
+  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 && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strcspn asan option
 // RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s1[] = "ab";
-  char s2[] = {'c', 'd'};
+  char s2[] = {'a'};
   char s3 = 0;
   r = strcspn(s1, s2);
   // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == sizeof(s1) - 1);
+  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 && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: ASAN_OPTIONS=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   char *r;
   char s2[] = "ab";
-  char s1[] = {'c', 'd'};
-  char s3[] = "a";
+  char s1[] = {'c', 'a'};
+  char s3 = 0;
   r = strpbrk(s1, s2);
   // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r <= s3);
+  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 && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strpbrk asan option
 // RUN: ASAN_OPTIONS=intercept_strpbrk=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   char *r;
-  char s1[] = "a";
+  char s1[] = "c";
   char s2[] = {'b', 'c'};
   char s3 = 0;
   r = strpbrk(s1, s2);
   // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == (r ? s1 : 0));
+  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 && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t r;
   char s2[] = "ab";
-  char s1[] = {'a', 'a'};
+  char s1[] = {'a', 'c'};
   char s3 = 0;
   r = strspn(s1, s2);
   // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r >= sizeof(s1));
+  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 && ASAN_OPTIONS=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // Test intercept_strspn asan option
 // RUN: ASAN_OPTIONS=intercept_strspn=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t r;
-  char s1[] = "cc";
+  char s1[] = "bbc";
   char s2[] = {'a', 'b'};
   char s3 = 0;
   r = strspn(s1, s2);
   // CHECK:'s{{[2|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == 0);
+  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 && ASAN_OPTIONS=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: ASAN_OPTIONS=intercept_strstr=false:replace_str=false %run %t 2>&1
 
 #include <assert.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   char *r = 0;
   char s2[] = "c";
-  char s1[] = {'a', 'b'};
+  char s1[] = {'a', 'c'};
   char s3 = 0;
   r = strstr(s1, s2);
   // CHECK:'s{{[1|3]}}' <== Memory access at offset {{[0-9]+ .*}}flows this variable
-  assert(r == 0);
+  assert(r == s1 + 1);
   return 0;
 }