[asan][test][win] Port trivial tests to not use clang-cl on MinGW

[alvinhochun]

Summary

Use clang driver on MinGW where clang-cl is not usable. MSVC target
still uses clang-cl to minimize changes to existing test runners.

[alvinhochun]

Add a missing chnage

[vitalybuka]

compiler-rt/test/asan/lit.cfg.py

166

please use substitutions instead

[alvinhochun]

Use substitution to map clang-cl command and flags to clang gcc-style flags on MinGW

[MaskRay]

IIUC -Od in MSVC (disable optimizations) is the default. -O0 is the default in Clang. Can we remove %Od from RUN lines?

[alvinhochun]

In D147432#4266456, @MaskRay wrote:

IIUC -Od in MSVC (disable optimizations) is the default. -O0 is the default in Clang. Can we remove %Od from RUN lines?

I'm not sure. Digging through the history shows they were previously using -O0 until that flag was replaced in https://reviews.llvm.org/D64506. The first instance of -O0 being added to the asan tests was https://reviews.llvm.org/D3767 with no explanation why it was needed. Curiously it seems only Windows tests using clang-cl had this flag. Was the default opt level for clang-cl different back then?

For cl.exe, https://learn.microsoft.com/en-us/cpp/build/reference/o-options-optimize-code?view=msvc-170 seems to indicate that /Ot is the default. Of course clang-cl doesn't have to match that, but I wonder if there is a possibility it may change in the future.

[vitalybuka]

Thanks, I like this version better.

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
+#ifdef __MINGW32__
+// FIXME: remove after mingw-w64 adds this declaration.
+extern "C" size_t __cdecl _aligned_msize(void *_Memory, size_t _Alignment,
+                                         size_t _Offset);
+#endif
+
 #define CHECK_ALIGNED(ptr,alignment) \
   do { \
     if (((uintptr_t)(ptr) % (alignment)) != 0) \
       return __LINE__; \
     } \
   while(0)
 
 int main(void) {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t | FileCheck %s
 
 #include <malloc.h>
 #include <stdio.h>
 
 int main() {
   int *p = (int*)malloc(1024 * sizeof(int));
   p[512] = 0;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 #include <process.h>
 
 unsigned WINAPI thread_proc(void *) {
   volatile char stack_buffer[42];
   for (int i = 0; i < sizeof(stack_buffer); ++i)

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
 typedef struct _S {
   unsigned int bf1:1;
   unsigned int bf2:2;
   unsigned int bf3:3;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 typedef struct _S {
   unsigned int bf1:1;
   unsigned int bf2:2;
   unsigned int bf3:3;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s
 
 // Test the error output from a breakpoint. Assertion-like macros often end in
 // int3 on Windows.
 
 #include <stdio.h>
 
 int main() {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *buffer = (int*)calloc(42, sizeof(int));
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*calloc_left_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 4 bytes before 168-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* calloc }}
 // CHECK-NEXT: {{#1 .* main .*calloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *buffer = (int*)calloc(42, sizeof(int));
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 4 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*calloc_right_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 0 bytes after 168-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* calloc }}
 // CHECK-NEXT: {{#1 .* main .*calloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *buffer = (int*)calloc(42, sizeof(int));
   free(buffer);
   buffer[0] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   int *x = (int*)malloc(42 * sizeof(int));
   free(x);
   free(x);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 
 int main(void) {
   static const char *foo = "foobarspam";
   printf("Global string is `%s`\n", foo);
 // CHECK: Global string is `foobarspam`
   return 0;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 
 extern "C" const char *foo = "foobarspam";
 
 int main(void) {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t 2>&1 | FileCheck %s
 #include <stdio.h>
 #include <windows.h>
 
 int main() {
   char *buffer;
   buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
   buffer[0] = 'a';
   HeapFree(GetProcessHeap(), 0, buffer);
   puts("Okay");
   // CHECK: Okay
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   printf("Hello, world!\n");
 // CHECK: Hello, world!
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %env_asan_opts=handle_sigill=1 not %run %t 2>&1 | FileCheck %s
 
 // Test the error output from an illegal instruction.
 
 #include <stdio.h>
 
 int main() {
   puts("before ud2a");
   fflush(stdout);
   __builtin_trap();
   return 0;
 }
 // CHECK: before ud2a
 // CHECK: ERROR: AddressSanitizer: illegal-instruction on unknown address [[ADDR:0x[^ ]*]]
 // CHECK-SAME: (pc [[ADDR]] {{.*}})
 // CHECK-NEXT: #0 {{.*}} in main {{.*}}illegal_instruction.cpp:{{.*}}

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %env_asan_opts=handle_sigfpe=1 not %run %t 2>&1 | FileCheck %s
 
 // Test the error output from dividing by zero.
 
 #include <stdio.h>
 
 int main() {
   puts("before ud2a");

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <string.h>
 
 void call_memcpy(void* (*f)(void *, const void *, size_t),
                  void *a, const void *b, size_t c) {
   f(a, b, c);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <string.h>
 #include <malloc.h>
 
 int main() {
   char *ptr = _strdup("Hello");

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <string.h>
 
 int main() {
   char str[] = "Hello";
   if (5 != strlen(str))

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*malloc_left_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* malloc }}
 // CHECK-NEXT: {{#1 .* main .*malloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*malloc_right_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 0 bytes after 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* malloc }}
 // CHECK-NEXT: {{#1 .* main .*malloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)malloc(42);
   free(buffer);
   buffer[0] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 // REQUIRES: asan-32-bits
 
 #include <malloc.h>
 
 int main() {
   while (true) {
     void *ptr = malloc(200 * 1024 * 1024);  // 200MB
   }
 // CHECK: SUMMARY: AddressSanitizer: out-of-memory
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   int *x = new int[42];
   delete (x + 1);
 // CHECK: AddressSanitizer: attempting free on address which was not malloc()-ed
 // CHECK:   {{#0 0x.* operator delete}}
 // CHECK:   {{#1 .* main .*operator_delete_wrong_argument.cpp}}:[[@LINE-3]]
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char;
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*operator_new_left_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 1 bytes before 1-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK:   {{#0 .* operator new}}
 // CHECK:   {{#1 .* main .*operator_new_left_oob.cpp}}:[[@LINE-8]]
   delete buffer;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char;
   buffer[1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK:   {{#0 .* main .*operator_new_right_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 0 bytes after 1-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK:   {{#0 .* operator new}}
 // CHECK:   {{#1 .* main .*operator_new_right_oob.cpp}}:[[@LINE-8]]
   delete buffer;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer = new char;
   delete buffer;
   *buffer = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 HANDLE done;
 
 DWORD CALLBACK work_item(LPVOID) {
   int subscript = -1;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*realloc_left_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 1 bytes before 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* realloc }}
 // CHECK-NEXT: {{#1 .* main .*realloc_left_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 42);
   buffer[42] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*realloc_right_oob.cpp}}:[[@LINE-3]]
 // CHECK: [[ADDR]] is located 0 bytes after 42-byte region
 // CHECK: allocated by thread T0 here:
 // CHECK-NEXT: {{#0 .* realloc }}
 // CHECK-NEXT: {{#1 .* main .*realloc_right_oob.cpp}}:[[@LINE-8]]
   free(buffer);
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 42);
   free(buffer);
   buffer[0] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 // REQUIRES: asan-32-bits
 
 #include <stdio.h>
 
 char bigchunk[1 << 30];
 
 int main() {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   int subscript = -1;
   char buffer[42];
   buffer[subscript] = 42;
 // CHECK: AddressSanitizer: stack-buffer-underflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}}:[[@LINE-3]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: {{#0 .* main .*stack_array_left_oob.cpp}}
 // CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] underflows this variable
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   int subscript = 42;
   char buffer[42];
   buffer[subscript] = 42;
 // CHECK: AddressSanitizer: stack-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
 // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}}:[[@LINE-3]]
 // CHECK: Address [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
 // CHECK-NEXT: {{#0 .* main .*stack_array_right_oob.cpp}}
 // CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] overflows this variable
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t | FileCheck %s
 
 #include <stdio.h>
 
 int main() {
   int subscript = 1;
   char buffer[42];
   buffer[subscript] = 42;
   printf("OK\n");
 // CHECK: OK
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc(void *) {
   volatile char stack_buffer[42];
   for (int i = 0; i < sizeof(stack_buffer); ++i)
     stack_buffer[i] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc(void *) {
   int subscript = -1;
   volatile char stack_buffer[42];
   stack_buffer[subscript] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc(void *) {
   int subscript = 42;
   volatile char stack_buffer[42];
   stack_buffer[subscript] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc_1(void *) {
   volatile int x, y, z;
   x = 1;
   y = 2;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc(void *) {
   volatile char stack_buffer[42];
   for (int i = 0; i < sizeof(stack_buffer); ++i)
     stack_buffer[i] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 #include <windows.h>
 
 DWORD WINAPI thread_proc(void *) {
   volatile char stack_buffer[42];
   for (int i = 0; i < sizeof(stack_buffer); ++i)
     stack_buffer[i] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {
   char *buffer = (char*)realloc(0, 32),
        *stale = buffer;
   buffer = (char*)realloc(buffer, 64);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: %run %t
 
 // Just make sure we can parse <windows.h>
 #include <windows.h>
 
 int main() {}

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 class Parent {
  public:
   int field;
 };
 
 class Child : public Parent {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %if clang-cl %{ %clang_cl_asan -Od %s -Fe%t %} \
+// RUN: %else %{ %clangxx_asan -O0 %s -o %t %}
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 class Parent {
  public:
   int field;
 };
 
 class Child : public Parent {

compiler-rt/test/asan/lit.cfg.py

if config.asan_dynamic:
 
   if shared_libasan_path is not None:
     config.substitutions.append( ("%shared_libasan", shared_libasan_path) )
   config.substitutions.append( ("%clang_asan_static ", build_invocation(clang_asan_static_cflags)) )
   config.substitutions.append( ("%clangxx_asan_static ", build_invocation(clang_asan_static_cxxflags)) )
 
 # MSVC-specific tests might also use the clang-cl.exe driver.
 if platform.system() == 'Windows' and target_is_msvc:
+  config.available_features.add("clang-cl")
   clang_cl_cxxflags = ["-Wno-deprecated-declarations",
                        "-WX",
                        "-D_HAS_EXCEPTIONS=0",
                        "-Zi"] + target_cflags
   clang_cl_asan_cxxflags = ["-fsanitize=address"] + clang_cl_cxxflags
   if config.asan_dynamic:
     clang_cl_asan_cxxflags.append("-MD")
 
   clang_cl_invocation = build_invocation(clang_cl_cxxflags)
   clang_cl_invocation = clang_cl_invocation.replace("clang.exe","clang-cl.exe")
   config.substitutions.append( ("%clang_cl ", clang_cl_invocation) )
 
   clang_cl_asan_invocation = build_invocation(clang_cl_asan_cxxflags)
   clang_cl_asan_invocation = clang_cl_asan_invocation.replace("clang.exe","clang-cl.exe")
   config.substitutions.append( ("%clang_cl_asan ", clang_cl_asan_invocation) )
 
   base_lib = os.path.join(config.compiler_rt_libdir, "clang_rt.asan%%s%s.lib" % config.target_suffix)
   config.substitutions.append( ("%asan_lib", base_lib % "") )
   config.substitutions.append( ("%asan_cxx_lib", base_lib % "_cxx") )
   config.substitutions.append( ("%asan_dll_thunk", base_lib % "_dll_thunk") )
 
 # FIXME: De-hardcode this path.
 asan_source_dir = os.path.join(