[asan][test] Fix tests or mark XFAIL for MinGW target

[alvinhochun]

Summary

After this change, check-asan-dynamic should pass on x86_64 MinGW
target, using the llvm-mingw toolchain.

The following is a list of issues fixed:

• asan_str_test.cpp: Exclude unintercepted functions on MinGW.
• asan_test.cpp: Work around regex limitation of gtest on Windows, which only affects MinGW target because long double has different size to double.
• TestCases/Windows/report_after_syminitialize.cpp: Added build command specifically for MinGW.
• Other tests: Mark XFAIL for various reasons. Some of them need further investigation.

Depends on D146908, D147232 and D147057

[mstorsjo]

compiler-rt/lib/asan/tests/asan_str_test.cpp

114

For cases like these, it should hopefully not be hard to move the strnlen function from libmingwex.a into libmsvcr*.a, to make it use the one from UCRT.

compiler-rt/lib/asan/tests/asan_test.cpp

208

If this is specific to Windows, why is this different from the case with MSVC/clang-cl?

compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cpp

6

In which way does it fail - what does %clangxx_asan expand to in that case?

compiler-rt/test/asan/TestCases/alloca_big_alignment.cpp

9 ↗

(On Diff #509046)

I think the changes from long to intptr_t could go into a separate patch, as those are useful to have in any case. I guess the thing is that clang warns about different things in clang-cl mode than in regular gcc-style mode, and this warning wasn't visible in clang-cl mode?

compiler-rt/test/asan/TestCases/atoll_strict.c

14

Or just generalize into `{{.*windows-.*}}?

[alvinhochun]

Fix Debian tests, hopefully.

[alvinhochun]

compiler-rt/lib/asan/tests/asan_test.cpp

208

MSVC target shouldn't reach here anyway because if (sizeof(long double) == sizeof(double)) is true. I guess I can change it to _WIN32 though.

compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cpp

6

It fails because it's missing -ldbghelp, which MSVC target doesn't need thanks to the #pragma lib comment.

compiler-rt/test/asan/TestCases/alloca_big_alignment.cpp

9 ↗

(On Diff #509046)

It actually errors out on MinGW target in my test. No idea why that would not be an issue for MSVC target.

compiler-rt/test/asan/TestCases/atoll_strict.c

14

I was thinking of making it more explicit to point out that, yes this test is XFAIL for both msvc and gnu targets.

[alvinhochun]

Appease clang-format

[pengfei]

compiler-rt/lib/asan/tests/asan_test.cpp

208

Clang has option to override it, see https://godbolt.org/z/1x9Pd9Tfx

[mstorsjo]

compiler-rt/lib/asan/tests/asan_test.cpp

208

Thanks - although we're not interested in making the MSVC target run this code - I was just wondering why this issue only appeared now.

@alvinhochun Changing it to _WIN32 probably is a good idea for clarity, and then mention the long double issue in the commit message regarding that particular change.

compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cpp

6

Ok, I see. This is kinda tricky and somewhat brittle, but I guess it can be ok.

compiler-rt/test/asan/TestCases/atoll_strict.c

14

Ok, fair enough.

[alvinhochun]

Change as per comments

[mstorsjo]

Overall LGTM, but I think it maybe would be nicer to split out the long->intptr_t changes into a separate patch.

[alvinhochun]

Split the long -> intptr_t change to D147232

[mstorsjo]

LGTM, thanks!

I'm still not entirely a fan of the brittle test that tries to link in two different ways though, but I guess it can be tolerable if it's only this one test.

compiler-rt/lib/asan/tests/asan_str_test.cpp

TEST(AddressSanitizer, WcsLenTest) {
   wchar_t *heap_string = Ident((wchar_t*)malloc(hello_size));
   memcpy(heap_string, L"Hello, World!", hello_size);
   EXPECT_EQ(hello_len, Ident(wcslen(heap_string)));
   EXPECT_DEATH(Ident(wcslen(heap_string + 14)), RightOOBReadMessage(0));
   free(heap_string);
 }
 #endif
 
+// This test fails on MinGW-w64 because it still ships a static copy of strnlen
+// despite it being available from UCRT.
+#if defined(__MINGW32__)
+#  define MAYBE_StrNLenOOBTest DISABLED_StrNLenOOBTest
+#else
+#  define MAYBE_StrNLenOOBTest StrNLenOOBTest
+#endif
+
 #if SANITIZER_TEST_HAS_STRNLEN
-TEST(AddressSanitizer, StrNLenOOBTest) {
+TEST(AddressSanitizer, MAYBE_StrNLenOOBTest) {
   size_t size = Ident(123);
   char *str = MallocAndMemsetString(size);
   // Normal strnlen calls.
   Ident(strnlen(str - 1, 0));
   Ident(strnlen(str, size));
   Ident(strnlen(str + size - 1, 1));
   str[size - 1] = '\0';
   Ident(strnlen(str, 2 * size));
   // Argument points to not allocated memory.
   EXPECT_DEATH(Ident(strnlen(str - 1, 1)), LeftOOBReadMessage(1));
   EXPECT_DEATH(Ident(strnlen(str + size, 1)), RightOOBReadMessage(0));
   // Overwrite the terminating '\0' and hit unallocated memory.
   str[size - 1] = 'z';
   EXPECT_DEATH(Ident(strnlen(str, size + 1)), RightOOBReadMessage(0));
   free(str);
 }
 #endif  // SANITIZER_TEST_HAS_STRNLEN
 
 // This test fails with the WinASan dynamic runtime because we fail to intercept
 // strdup.
-#if defined(_MSC_VER) && defined(_DLL)
-#define MAYBE_StrDupOOBTest DISABLED_StrDupOOBTest
+#if (defined(_MSC_VER) && defined(_DLL)) || defined(__MINGW32__)
+#  define MAYBE_StrDupOOBTest DISABLED_StrDupOOBTest
 #else
-#define MAYBE_StrDupOOBTest StrDupOOBTest
+#  define MAYBE_StrDupOOBTest StrDupOOBTest
 #endif
 
 TEST(AddressSanitizer, MAYBE_StrDupOOBTest) {
   size_t size = Ident(42);
   char *str = MallocAndMemsetString(size);
   char *new_str;
   // Normal strdup calls.
   str[size - 1] = '\0';

compiler-rt/lib/asan/tests/asan_test.cpp

TEST(AddressSanitizer, UAF_char) {
   EXPECT_DEATH(uaf_test<U1>(10, 10), uaf_string);
   EXPECT_DEATH(uaf_test<U1>(kLargeMalloc, 0), uaf_string);
   EXPECT_DEATH(uaf_test<U1>(kLargeMalloc, kLargeMalloc / 2), uaf_string);
 }
 
 TEST(AddressSanitizer, UAF_long_double) {
   if (sizeof(long double) == sizeof(double)) return;
   long double *p = Ident(new long double[10]);
+#if defined(_WIN32)
+  // https://google.github.io/googletest/advanced.html#regular-expression-syntax
+  // GoogleTest's regular expression engine on Windows does not support `[]`
+  // brackets.
+  EXPECT_DEATH(Ident(p)[12] = 0, "WRITE of size 10");
+  EXPECT_DEATH(Ident(p)[0] = Ident(p)[12], "READ of size 10");
+#else
   EXPECT_DEATH(Ident(p)[12] = 0, "WRITE of size 1[026]");
   EXPECT_DEATH(Ident(p)[0] = Ident(p)[12], "READ of size 1[026]");
+#endif
   delete [] Ident(p);
 }
 
 #if !defined(_WIN32)
 struct Packed5 {
   int x;
   char c;
 } __attribute__((packed));

compiler-rt/lib/sanitizer_common/tests/sanitizer_test_utils.h

 #endif
 
 #if defined(__FreeBSD__) || defined(__NetBSD__)
 # define SANITIZER_TEST_HAS_PRINTF_L 1
 #else
 # define SANITIZER_TEST_HAS_PRINTF_L 0
 #endif
 
-#if !defined(_MSC_VER)
-# define SANITIZER_TEST_HAS_STRNDUP 1
+#if !defined(_WIN32)
+#  define SANITIZER_TEST_HAS_STRNDUP 1
 #else
 # define SANITIZER_TEST_HAS_STRNDUP 0
 #endif
 
 #endif  // SANITIZER_TEST_UTILS_H

compiler-rt/test/asan/TestCases/Windows/coverage-basic.cpp

 // RUN: rm -rf %t-dir
 // RUN: mkdir %t-dir && cd %t-dir
 // RUN: %clangxx_asan -fsanitize-coverage=func,trace-pc-guard %s -o test.exe
 // RUN: %env_asan_opts=coverage=1 %run ./test.exe
 //
 // RUN: %sancov print *.sancov | FileCheck %s
+
+// FIXME: Investigate failure on MinGW.
+// XFAIL: target={{.*-windows-gnu}}
+
 #include <stdio.h>
 
 void foo() { fputs("FOO", stderr); }
 void bar() { fputs("BAR", stderr); }
 
 int main(int argc, char **argv) {
   if (argc == 2) {
     foo();

compiler-rt/test/asan/TestCases/Windows/report_after_syminitialize.cpp

-// RUN: %clangxx_asan -O0 %s -o %t
+// This test works on both MSVC and MinGW targets, but they require different
+// build commands. By default we use DWARF debug info on MinGW and dbghelp does
+// not support it, so we need to specify extra flags to get the compiler to
+// generate PDB debug info.
+
+// The first build command is intended for MSVC target, which fails on MinGW.
+// The second build command contains the flags required to get PDB debug info
+// on a MinGW build, which fails on MSVC.
+
+// RUN: %clangxx_asan -O0 %s -o %t \
+// RUN: || %clangxx_asan -gcodeview -gcolumn-info -Wl,--pdb= -O0 %s -o %t -ldbghelp
 // RUN: %env_asan_opts=external_symbolizer_path=non-existent\\\\asdf not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <dbghelp.h>
 
 #pragma comment(lib, "dbghelp")
 
 int main() {

compiler-rt/test/asan/TestCases/atexit_stats.cpp

 // Make sure we report atexit stats.
 // RUN: %clangxx_asan -O3 %s -o %t
 // RUN: %env_asan_opts=atexit=1:print_stats=1 %run %t 2>&1 | FileCheck %s
 //
 // No atexit output in older versions of Android due to
 // https://code.google.com/p/address-sanitizer/issues/detail?id=263
 // UNSUPPORTED: android
 
+// FIXME: Investigate failure on MinGW.
+// XFAIL: target={{.*-windows-gnu}}
+
 #include <stdlib.h>
 #if !defined(__APPLE__) && !defined(__FreeBSD__) && !defined(__NetBSD__)
 #include <malloc.h>
 #endif
 int *p1 = (int*)malloc(900);
 int *p2 = (int*)malloc(90000);
 int *p3 = (int*)malloc(9000000);
 int main() { }
 
 // CHECK: AddressSanitizer exit stats:

compiler-rt/test/asan/TestCases/atoll_strict.c

 // Test strict_string_checks option in atoll function
 // RUN: %clang_asan %s -o %t
 // RUN: %run %t test1 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test1 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test1 2>&1 | FileCheck %s --check-prefix=CHECK1
 // RUN: %run %t test2 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test2 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test2 2>&1 | FileCheck %s --check-prefix=CHECK2
 // RUN: %run %t test3 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test3 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test3 2>&1 | FileCheck %s --check-prefix=CHECK3
 
 // FIXME: Needs Windows interceptor.
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 void test1(char *array) {
   // Last symbol is non-digit
   memset(array, '1', 10);

compiler-rt/test/asan/TestCases/frexpl_interceptor.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // Test the frexpl() interceptor.
 
+// FIXME: MinGW-w64 implements `frexpl()` as a static import, so the dynamic
+// interceptor seems to not work.
+// XFAIL: target={{.*-windows-gnu}}
+
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 int main() {
   long double x = 3.14;
   int *exp = (int *)malloc(sizeof(int));
   free(exp);
   double y = frexpl(x, exp);
   // CHECK: use-after-free
   // CHECK: SUMMARY
   return 0;
 }

compiler-rt/test/asan/TestCases/global-location.cpp

 // RUN: %clangxx_asan -g -O2 %s -o %t
 // RUN: not %run %t g 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=GLOB
 // RUN: not %run %t c 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=CLASS_STATIC
 // RUN: not %run %t f 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=FUNC_STATIC
 // RUN: not %run %t l 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=LITERAL
 
 // COFF doesn't support debuginfo for globals. For the non-debuginfo tests, see global-location-nodebug.cpp.
 // XFAIL: target={{.*windows-msvc.*}}
 
+// FIXME: Investigate failure on MinGW
+// XFAIL: target={{.*-windows-gnu}}
+
 // atos doesn't show source line numbers for global variables.
 // UNSUPPORTED: darwin
 
 // CHECK: AddressSanitizer: global-buffer-overflow
 
 #include <string.h>
 
 struct C {

compiler-rt/test/asan/TestCases/heavy_uar_test.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O0 %s -o %t -fsanitize-address-use-after-return=always && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t -fsanitize-address-use-after-return=always && not %run %t 2>&1 | FileCheck %s
 // XFAIL: target={{.*windows-msvc.*}}
 
+// FIXME: Investigate failure on MinGW. MinGW ASAN produces a different report:
+//        stack-overflow on address
+// XFAIL: target={{.*-windows-gnu}}
+
 // FIXME: Fix this test under GCC.
 // REQUIRES: Clang
 
 // FIXME: Fix this test for dynamic runtime on arm linux.
 // UNSUPPORTED: (arm-linux || armhf-linux) && asan-dynamic-runtime
 
 // UNSUPPORTED: ios
 

compiler-rt/test/asan/TestCases/init-order-atexit.cpp

 // Test for the following situation:
 // (1) global A is constructed.
 // (2) exit() is called during construction of global B.
 // (3) destructor of A reads uninitialized global C from another module.
 // We do *not* want to report init-order bug in this case.
 
 // RUN: %clangxx_asan -O0 %s %p/Helpers/init-order-atexit-extra.cpp -o %t
 // RUN: %env_asan_opts=strict_init_order=true not %run %t 2>&1 | FileCheck %s
 
+// FIXME: Investigate failure on MinGW
+// XFAIL: target={{.*-windows-gnu}}
+
 #include <stdio.h>
 #include <stdlib.h>
 
 void AccessC();
 
 class A {
  public:
   A() { }

compiler-rt/test/asan/TestCases/printf-2.c

 // RUN: %clang_asan -O2 %s -o %t
 // We need replace_str=0, intercept_strlen=0 and replace_intrin=0 to avoid
 // reporting errors in strlen() and memcpy() called by printf().
 // RUN: %env_asan_opts=replace_str=0:intercept_strlen=0:replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 // RUN: %env_asan_opts=replace_str=0:intercept_strlen=0:replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
 // RUN: %env_asan_opts=replace_str=0:intercept_strlen=0:replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 
 // FIXME: printf is not intercepted on Windows yet.
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 int main() {
   volatile char c = '0';
   volatile int x = 12;
   volatile float f = 1.239;

compiler-rt/test/asan/TestCases/printf-3.c

 // RUN: %clang_asan -O2 %s -o %t
 // RUN: %env_asan_opts=check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 // RUN: %env_asan_opts=check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 
 // FIXME: printf is not intercepted on Windows yet.
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 // New Bionic rejects %n
 // https://android.googlesource.com/platform/bionic/+/41398d03b7e8e0dfb951660ae713e682e9fc0336
 // UNSUPPORTED: android
 
 #include <stdio.h>
 int main() {
 #ifdef _MSC_VER

compiler-rt/test/asan/TestCases/printf-5.c

 // RUN: %clang_asan -O2 %s -o %t
 // We need replace_intrin=0 to avoid reporting errors in memcpy.
 // RUN: %env_asan_opts=replace_intrin=0:check_printf=1 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 // RUN: %env_asan_opts=replace_intrin=0:check_printf=0 %run %t 2>&1 | FileCheck --check-prefix=CHECK-OFF %s
 // RUN: %env_asan_opts=replace_intrin=0 not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 
 // FIXME: printf is not intercepted on Windows yet.
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <stdio.h>
 #include <string.h>
 int main() {
   volatile char c = '0';
   volatile int x = 12;
   volatile float f = 1.239;
   volatile char s[] = "34";
   volatile char fmt[2] = "%c %d %f %s\n";
   printf((char *)fmt, c, x, f, s);
   return 0;
   // Check that format string is sanitized.
   // CHECK-ON: stack-buffer-overflow
   // CHECK-ON-NOT: 0 12 1.239 34
   // CHECK-OFF: 0
 }

compiler-rt/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: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #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[4] = "abC";
   __asan_poison_memory_region ((char *)&s1[2], 2);
   r = strcasestr(s1, s2);
   // CHECK:'s1'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   assert(r == s1 + 2);
   return 0;
 }

compiler-rt/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:intercept_strlen=false %run %t 2>&1
 
 // There's no interceptor for strcasestr on Windows
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #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[4] = "cba";
   __asan_poison_memory_region ((char *)&s2[2], 2);
   r = strcasestr(s1, s2);
   assert(r == 0);
   // CHECK:'s2'{{.*}} <== Memory access at offset {{[0-9]+}} partially overflows this variable
   return 0;
 }

compiler-rt/test/asan/TestCases/strcasestr_strict.c

 // Test strict_string_checks option in strcasestr function
 // RUN: %clang_asan %s -o %t && %run %t 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t 2>&1 | FileCheck %s
 
 // There's no interceptor for strcasestr on Windows
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t size = 100;

compiler-rt/test/asan/TestCases/strncasecmp_strict.c

 // Test strict_string_checks option in strncmp function
 // RUN: %clang_asan %s -o %t
 
 // RUN: %env_asan_opts=strict_string_checks=false %run %t a 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true %run %t a 2>&1
 // RUN: not %run %t b 2>&1 | FileCheck %s
 // RUN: not %run %t c 2>&1 | FileCheck %s
 // RUN: not %run %t d 2>&1 | FileCheck %s
 // RUN: not %run %t e 2>&1 | FileCheck %s
 // RUN: not %run %t f 2>&1 | FileCheck %s
 // RUN: not %run %t g 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=strict_string_checks=false %run %t h 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t h 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=strict_string_checks=false %run %t i 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t i 2>&1 | FileCheck %s
 
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 
 int main(int argc, char **argv) {

compiler-rt/test/asan/TestCases/strtoll_strict.c

 // RUN: %env_asan_opts=strict_string_checks=false %run %t test6 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test6 2>&1 | FileCheck %s --check-prefix=CHECK6
 // RUN: %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=false %run %t test7 2>&1
 // RUN: %env_asan_opts=strict_string_checks=true not %run %t test7 2>&1 | FileCheck %s --check-prefix=CHECK7
 
 // FIXME: Enable strtoll interceptor.
 // REQUIRES: shadow-scale-3
-// XFAIL: target={{.*windows-msvc.*}}
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sanitizer/asan_interface.h>
 
 void test1(char *array, char *endptr) {
   // Buffer overflow if there is no terminating null (depends on base)

compiler-rt/test/asan/TestCases/time_interceptor.cpp

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // Test the time() interceptor.
 
-// There's no interceptor for time() on Windows yet.
-// XFAIL: target={{.*windows-msvc.*}}
+// FIXME: There's no interceptor for time() on Windows yet.
+// XFAIL: target={{.*windows-(msvc.*|gnu)}}
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 
 int main() {
   time_t *tm = (time_t*)malloc(sizeof(time_t));
   free(tm);
   time_t t = time(tm);
   printf("Time: %s\n", ctime(&t));
   // CHECK: use-after-free
   // Regression check for
   // https://code.google.com/p/address-sanitizer/issues/detail?id=321
   // CHECK: SUMMARY
   return 0;
 }