[asan][test][win] Port more tests to not use clang-cl on MinGW (2)

[alvinhochun]

Summary

Continuation of D147432 and D147444.

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 // Build an executable with ASan, then extract the DLLs that it depends on.
-// RUN: %clang_cl_asan %s -Fe%t.exe
+// RUN: %clang_cl_asan %s %Fe%t.exe
 // RUN: llvm-readobj --coff-imports %t.exe | grep Name: | sed -e 's/ *Name: *//' > %t
 //
 // Make sure the binary doesn't depend on dbghelp directly.
 // RUN: not grep dbghelp.dll %t
 //
 // Make sure any clang_rt DLLs it depends on don't depend on dbghelp. In the
 // static build, there won't be any clang_rt DLLs.
 // RUN: not grep cl""ang_rt %t || \
 // RUN:   grep cl""ang_rt %t | xargs which | \
 // RUN:   xargs llvm-readobj --coff-imports | not grep dbghelp.dll %t
 
 extern "C" int puts(const char *);
 
 int main() {
   puts("main");
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: %run %t %t.dll | FileCheck %s
 
 #include <malloc.h>
 #include <stdio.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)
 
 extern "C" __declspec(dllexport)

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: %run %t %t.dll | FileCheck %s
 
 #include <malloc.h>
 #include <stdio.h>
 
 extern "C" __declspec(dllexport)
 int test_function() {
   int *p = (int*)malloc(1024 * sizeof(int));

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 // On windows 64-bit, the memchr function is written in assembly and is not
 // hookable with the interception library. There is not enough padding before
 // the function and there is a short jump on the second instruction which
 // doesn't not allow enough space to encode a 64-bit indirect jump.
 // UNSUPPORTED: x86_64-windows
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 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/dll_intercept_strlen.cpp

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <stdio.h>
 #include <string.h>
 
 extern "C" __declspec(dllexport)
 int test_function() {
   char str[] = "Hello!";

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <malloc.h>
 extern "C" __declspec(dllexport)
 int test_function() {
   char *buffer = (char*)malloc(42);
   buffer[-1] = 42;
 // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 extern "C" __declspec(dllexport)
 int test_function() {
   int *buffer = (int*)malloc(42);
   free(buffer);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <process.h>
 
 void noreturn_f() {
   int subscript = -1;
   char buffer[42];
   buffer[subscript] = 42;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 __attribute__((noinline))
 static void NullDeref(int *ptr) {
   // CHECK: ERROR: AddressSanitizer: access-violation on unknown address
   // CHECK:   {{0x0*000.. .*pc 0x.*}}
   ptr[10]++;  // BOOM
 }
 
 extern "C" __declspec(dllexport)
 int test_function() {
   NullDeref((int*)0);
   // CHECK: {{    #1 0x.* in test_function .*\dll_null_deref.cpp:}}[[@LINE-1]]
   // CHECK: AddressSanitizer can not provide additional info.
   return 0;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 extern "C" __declspec(dllexport)
 int test_function() {
   char *buffer = new char[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

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 struct C {
   int x;
   ~C() {}
 };
 
 int __attribute__((noinline, optnone)) hide(int x) { return x; }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <sanitizer/asan_interface.h>
 
 void should_not_crash(volatile char *c) {
   *c = 42;
 }
 
 void should_crash(volatile char *c) {
   *c = 42;
 }
 
 extern "C" __declspec(dllexport)
 int test_function() {
   char buffer[256];
   should_not_crash(&buffer[0]);
   __asan_poison_memory_region(buffer, 128);
   should_not_crash(&buffer[192]);
   __asan_unpoison_memory_region(buffer, 64);
   should_not_crash(&buffer[32]);
 
   should_crash(&buffer[96]);
 // CHECK: AddressSanitizer: use-after-poison on address [[ADDR:0x[0-9a-f]+]]
 // CHECK-NEXT: WRITE of size 1 at [[ADDR]] thread T0
-// CHECK-NEXT: should_crash{{.*}}\dll_poison_unpoison.cpp
-// CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cpp:[[@LINE-4]]
+// CHECK-NEXT: should_crash{{.*[\\/]}}dll_poison_unpoison.cpp
+// CHECK-NEXT: test_function{{.*[\\/]}}dll_poison_unpoison.cpp:[[@LINE-4]]
 // CHECK-NEXT: main
 //
 // CHECK: [[ADDR]] is located in stack of thread T0 at offset [[OFFSET:.*]] in frame
-// CHECK-NEXT: test_function{{.*}}\dll_poison_unpoison.cpp
+// CHECK-NEXT: test_function{{.*[\\/]}}dll_poison_unpoison.cpp
 // CHECK: 'buffer'{{.*}} <== Memory access at offset [[OFFSET]] is inside this variable
   return 0;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t %t.dll 2>&1 | FileCheck %s
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll -fsanitize-address-use-after-return=always
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll -fsanitize-address-use-after-return=always
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 char *x;
 
 void foo() {
   char stack_buffer[42];

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %p/dll_host.cpp -Fe%t
-// RUN: %clang_cl_asan -LD -Od %s -Fe%t.dll
+// RUN: %clang_cl_asan %Od %p/dll_host.cpp %Fe%t
+// RUN: %clang_cl_asan %LD %Od %s %Fe%t.dll
 // RUN: not %run %t %t.dll 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <malloc.h>
 
 DWORD WINAPI thread_proc(void *context) {
   int subscript = -1;
   char stack_buffer[42];

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include <stdio.h>
 #include <windows.h>
 
-// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
 // REQUIRES: asan-dynamic-runtime
 // REQUIRES: asan-32-bits
 
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 extern "C" {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 // UNSUPPORTED: asan-64-bits
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 
 #include <windows.h>
 
 int main() {
   char *buffer;
   buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
   buffer[33] = 'a';
   // CHECK: AddressSanitizer: heap-buffer-overflow on address [[ADDR:0x[0-9a-f]+]]
   // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include <stdio.h>
 #include <windows.h>
 
-// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
 // REQUIRES: asan-dynamic-runtime
 // REQUIRES: asan-32-bits
 
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 extern "C" {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include <stdio.h>
 #include <windows.h>
 
-// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
 // REQUIRES: asan-dynamic-runtime
 // REQUIRES: asan-32-bits
 
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 extern "C" {

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <cassert>
 #include <windows.h>
 
 int main() {
   void *allocation = HeapAlloc(GetProcessHeap(), 0, 10);
   assert(allocation != 0);
   assert(HeapFree(GetProcessHeap(), 0, allocation));
   HeapFree(GetProcessHeap(), 0, allocation); //will dump
   assert(0 && "HeapFree double free should produce an ASAN dump\n");
   return 0;
 }
 
 // CHECK: AddressSanitizer: attempting double-free on [[addr:0x[0-9a-fA-F]+]] in thread T0:

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <assert.h>
 #include <stdio.h>
 #include <windows.h>
 
 extern "C" int

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=allocator_may_return_null=true %run %t
 // RUN: %env_asan_opts=allocator_may_return_null=true:windows_hook_rtl_allocators=true %run %t
 // UNSUPPORTED: asan-64-bits
 #include <windows.h>
 int main() {
   void *nope = HeapAlloc(GetProcessHeap(), 0, ((size_t)0) - 1);
   return (nope == nullptr) ? 0 : 1;
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include "sanitizer\allocator_interface.h"
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 
 // RUN: %clang_cl_asan %s -o%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
for (int i = 100; i < usable_size; i++) {
     assert(((char *)alloc)[i] == 0);
   }
 
   printf("Success\n");
 }
 
 // CHECK-NOT: Assertion failed:
 // CHECK-NOT: AddressSanitizer
-// CHECK: Success
+// CHECK: Success
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include "sanitizer\allocator_interface.h"
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 // RUN: %clang_cl_asan %s -o%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 
int main() {
   //convert back to rtl owned;
   alloc = HeapReAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, realloc, 100);
   assert(alloc && !__sanitizer_get_ownership(alloc) && HeapValidate(GetProcessHeap(), 0, alloc));
   printf("Success\n");
 }
 
 // CHECK-NOT: assert
 // CHECK-NOT: AddressSanitizer
-// CHECK: Success
+// CHECK: Success
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <windows.h>
 
 int main() {
   char *buffer;
   buffer = (char *)HeapAlloc(GetProcessHeap(), 0, 32),
   HeapFree(GetProcessHeap(), 0, buffer);
   buffer[0] = 'a';
   // CHECK: AddressSanitizer: heap-use-after-free on address [[ADDR:0x[0-9a-f]+]]
   // CHECK: WRITE of size 1 at [[ADDR]] thread T0
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan /Od -o %t %s
+// RUN: %clang_cl_asan %Od -o %t %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
-// RUN: %clang_cl /Od -o %t %s
+// RUN: %clang_cl %Od -o %t %s
 // RUN: %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>
 
 int main() {
   HANDLE heap = HeapCreate(0, 0, 0);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <stdio.h>
 #include <windows.h>
 
 int main() {
   char *oldbuf;
   size_t sz = 8;

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan /Od /MT -o %t %s
+// RUN: %clang_cl_asan %Od %MT -o %t %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <cassert>
 #include <iostream>
 #include <windows.h>
 
 int main() {
   void *ptr = malloc(0);
int main() {
   }
   HeapFree(GetProcessHeap(), 0, ptr3);
   return 0;
 }
 
 // CHECK: allocated!
 // CHECK-NOT: heap-buffer-overflow
 // CHECK-NOT: AddressSanitizer
-// CHECK-NOT: HeapAlloc size failure!
+// CHECK-NOT: HeapAlloc size failure!
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan /Od -o %t %s
+// RUN: %clang_cl_asan %Od -o %t %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=false %run %t 2>&1 | FileCheck %s
-// RUN: %clang_cl /Od -o %t %s
+// RUN: %clang_cl %Od -o %t %s
 // RUN: %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 #include <cassert>
 #include <stdio.h>
 #include<windows.h>
 
 int main() {
   HANDLE heap = HeapCreate(0, 0, 0);
   void *ptr = HeapAlloc(heap, 0, 4);
   assert(ptr);
   void *ptr2 = HeapReAlloc(heap, 0, ptr, 0);
   assert(ptr2);
   HeapFree(heap, 0, ptr2);
   fprintf(stderr, "passed!\n");
 }
 
 // CHECK-NOT: double-free
 // CHECK-NOT: AddressSanitizer
-// CHECK: passed!
+// CHECK: passed!
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 // Workaround for "LINK : fatal error LNK1318: Unexpected PDB error"
 // RUN: rm -f %t.pdb
 
 // RUN: %clang_cl_asan %s -o %t.exe
 // RUN: %run %t.exe 2>&1 | FileCheck %s
 // RUN: %clang_cl %s -o %t.exe
 // RUN: %run %t.exe 2>&1 | FileCheck %s
 
int main() {
   for (int i = 100; i < 200; i++) {
     assert(((BYTE *)nnnp)[i] == 0);
   }
   fprintf(stderr, "passed\n");
   return 0;
 }
 
 // CHECK-NOT: Assertion
-// CHECK: passed
+// CHECK: passed
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 // Make sure we can handle reloading the same DLL multiple times.
-// RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl_asan %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=report_globals=1 %run %te.exe %t.dll 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 #include <string.h>
 
 extern "C" {
 #if defined(EXE)

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -LD -Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl_asan -Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl_asan %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=report_globals=2 %run %te.exe %t.dll 2>&1 | FileCheck %s
 
 #include <windows.h>
 #include <stdio.h>
 #include <string.h>
 
 extern "C" {
 #if defined(EXE)

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t /MD
+// RUN: %clang_cl_asan %Od %s %Fe%t %MD
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 // REQUIRES: asan-rtl-heap-interception
 
 #include <stdio.h>
 #include <windows.h>
 
 using AllocateFunctionPtr = PVOID(__stdcall *)(PVOID, ULONG, SIZE_T);

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
 // REQUIRES: asan-dynamic-runtime
 // REQUIRES: asan-32-bits
 // REQUIRES: asan-rtl-heap-interception
 
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -LD /Od -DDLL %s -Fe%t.dll
-// RUN: %clang_cl /Od -DEXE %s -Fe%te.exe
+// RUN: %clang_cl_asan %LD %Od -DDLL %s %Fe%t.dll
+// RUN: %clang_cl %Od -DEXE %s %Fe%te.exe
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %te.exe %t.dll 2>&1 | FileCheck %s
 // REQUIRES: asan-dynamic-runtime
 // REQUIRES: asan-32-bits
 // REQUIRES: asan-rtl-heap-interception
 
 #include <cassert>
 #include <stdio.h>
 #include <windows.h>

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t /MD
+// RUN: %clang_cl_asan %Od %s %Fe%t %MD
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 // REQUIRES: asan-rtl-heap-interception
 
 #include <assert.h>
 #include <stdio.h>
 #include <windows.h>
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t /MD
+// RUN: %clang_cl_asan %Od %s %Fe%t %MD
 // RUN: %env_asan_opts=windows_hook_rtl_allocators=true not %run %t 2>&1 | FileCheck %s
 // UNSUPPORTED: asan-64-bits
 // REQUIRES: asan-rtl-heap-interception
 
 #include <assert.h>
 #include <stdio.h>
 #include <windows.h>
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 #include <Windows.h>
 #include <stdio.h>
 #include <sanitizer/allocator_interface.h>
 #include <psapi.h>
 
-// RUN: %clang_cl_asan -Od %s -Fe%t 
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %t
 // REQUIRES: asan-64-bits
 
 size_t GetRSS() {
   PROCESS_MEMORY_COUNTERS counters;
   if (!GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters)))
     return 0;
   return counters.WorkingSetSize;
 }
 
 int main(){
     for (int i = 0; i < 1000; i++) {
         void* a = malloc(1000);
         free(a);
     }
     size_t rss_pre  = GetRSS();
     __sanitizer_purge_allocator();
     size_t rss_post = GetRSS();
 
     if (rss_pre <= rss_post){
         return -1;
     }
 
     return 0;
-}
+}
 

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: %env_asan_opts=detect_stack_use_after_return=1 not %run %t 2>&1 | FileCheck %s
-// RUN: %clang_cl_asan -Od %s -Fe%t -fsanitize-address-use-after-return=always
+
+// RUN: %clang_cl_asan %Od %s %Fe%t -fsanitize-address-use-after-return=always
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 char *x;
 
 void foo() {
   char stack_buffer[42];
   x = &stack_buffer[13];
 }

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

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
 // Make sure symbolization works even if the path to the .exe file changes.
 // RUN: mkdir %t || true
-// RUN: %clang_cl_asan -Od %s -Fe%t/symbols_path.exe
+// RUN: %clang_cl_asan %Od %s %Fe%t/symbols_path.exe
 // RUN: not %run %t/symbols_path.exe 2>&1 | FileCheck %s
 // RUN: mkdir %t2 || true
 // RUN: mv %t/* %t2
 // RUN: not %run %t2/symbols_path.exe 2>&1 | FileCheck %s
 
 #include <malloc.h>
 
 int main() {

compiler-rt/test/asan/TestCases/Windows/user-exception.cpp

-// UNSUPPORTED: target={{.*-windows-gnu}}
-
-// RUN: %clang_cl_asan -Od %s -Fe%t
+// RUN: %clang_cl_asan %Od %s %Fe%t
 // RUN: env ASAN_OPTIONS=handle_segv=0 %run %t 2>&1 | FileCheck %s --check-prefix=USER
 // RUN: env ASAN_OPTIONS=handle_segv=1 not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN
 // Test the default.
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=ASAN
 
 // This test exits zero when its unhandled exception filter is set. ASan should
 // not disturb it when handle_segv=0.
 

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

if target_is_msvc:
     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) )
     config.substitutions.append( ("%Od", "-Od") )
     config.substitutions.append( ("%Fe", "-Fe") )
+    config.substitutions.append( ("%LD", "-LD") )
+    config.substitutions.append( ("%MD", "-MD") )
+    config.substitutions.append( ("%MT", "-MT") )
 
     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") )
   else:
     # To make some of these tests work on MinGW target without changing their
     # behaviour for MSVC target, substitute clang-cl flags with gcc-like ones.
     config.substitutions.append( ("%clang_cl ", build_invocation(target_cxxflags)) )
     config.substitutions.append( ("%clang_cl_asan ", build_invocation(clang_asan_cxxflags)) )
     config.substitutions.append( ("%Od", "-O0") )
     config.substitutions.append( ("%Fe", "-o") )
+    config.substitutions.append( ("%LD", "-shared") )
+    config.substitutions.append( ("%MD", "") )
+    config.substitutions.append( ("%MT", "") )
 
 # FIXME: De-hardcode this path.
 asan_source_dir = os.path.join(
   get_required_attr(config, "compiler_rt_src_root"), "lib", "asan")
 python_exec = shlex.quote(get_required_attr(config, "python_executable"))
 # Setup path to asan_symbolize.py script.
 asan_symbolize = os.path.join(asan_source_dir, "scripts", "asan_symbolize.py")
 if not os.path.exists(asan_symbolize):