[CMake] Use normalized Windows target triples

[phosek]

Summary

Changes the default Windows target triple returned by
GetHostTriple.cmake from the old environment names (which we wanted to
move away from) to newer, normalized ones. This also requires updating
all tests to use the new systems names in constraints.

[rnk]

@compnerd @chapuni , are you on board with the new spelling of REQUIRES: win32? I think it makes sense, it's self-consistent. More descriptive, even.

[compnerd]

@rnk - Id say something more stronger than on board for this change. I think that this is a great cleanup, makes everything much clearer and generally simplifies the model that you have to work with. I didn't look at the changes to the test very carefully (they should be mechanical in nature). The rest LGTM.

[phosek]

Rebased the change, I think it's ready to land.

[rnk]

lgtm

test/asan/TestCases/Posix/mmap_limit_mb.cc

 // Test the mmap_limit_mb flag.
 //
 // RUN: %clangxx_asan -O2 %s -o %t
 // RUN: %run %t 20 16
 // RUN: %run %t 30 1000000
 // RUN: %env_asan_opts=mmap_limit_mb=300 %run %t 20 16
 // RUN: %env_asan_opts=mmap_limit_mb=300 %run %t 20 1000000
 // RUN: %env_asan_opts=mmap_limit_mb=300 not %run %t 500 16 2>&1 | FileCheck %s
 // RUN: %env_asan_opts=mmap_limit_mb=300 not %run %t 500 1000000 2>&1 | FileCheck %s
 //
 // FIXME: Windows doesn't implement mmap_limit_mb.
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <vector>
 

test/asan/TestCases/Posix/strndup_oob_test.cc

 // RUN: %clangxx_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clangxx_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // When built as C on Linux, strndup is transformed to __strndup.
 // RUN: %clangxx_asan -O3 -xc %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // Unwind problem on arm: "main" is missing from the allocation stack trace.
-// UNSUPPORTED: win32,s390,arm && !fast-unwinder-works
+// UNSUPPORTED: windows-msvc,s390,arm && !fast-unwinder-works
 
 #include <string.h>
 
 char kString[] = "foo";
 
 int main(int argc, char **argv) {
   char *copy = strndup(kString, 2);
   int x = copy[2 + argc];  // BOOM

test/asan/TestCases/Posix/strndup_oob_test2.cc

 // RUN: %clang_asan -O0 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_asan -O1 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_asan -O2 %s -o %t && not %run %t 2>&1 | FileCheck %s
 // RUN: %clang_asan -O3 %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // When built as C on Linux, strndup is transformed to __strndup.
 // RUN: %clang_asan -O3 -xc %s -o %t && not %run %t 2>&1 | FileCheck %s
 
 // Unwind problem on arm: "main" is missing from the allocation stack trace.
-// UNSUPPORTED: win32,s390,arm && !fast-unwinder-works
+// UNSUPPORTED: windows-msvc,s390,arm && !fast-unwinder-works
 
 #include <string.h>
 
 char kChars[] = { 'f', 'o', 'o' };
 
 int main(int argc, char **argv) {
   char *copy = strndup(kChars, 3);
   copy = strndup(kChars, 10);
   // CHECK: AddressSanitizer: global-buffer-overflow
   // CHECK: {{.*}}main {{.*}}.cc:[[@LINE-2]]
   return *copy;
 }

test/asan/TestCases/asan_and_llvm_coverage_test.cc

 // RUN: %clangxx_asan -coverage -O0 %s -o %t
 // RUN: %env_asan_opts=check_initialization_order=1 %run %t 2>&1 | FileCheck %s
 
 // We don't really support running tests using profile runtime on Windows.
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 #include <stdio.h>
 int foo() { return 1; }
 int XXX = foo();
 int main() {
   printf("PASS\n");
 // CHECK: PASS
 }

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: win32
+// XFAIL: windows-msvc
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 void test1(char *array) {
   // Last symbol is non-digit
   memset(array, '1', 10);

test/asan/TestCases/heavy_uar_test.cc

 // 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
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 // 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

test/asan/TestCases/initialization-bug.cc

 // Test to make sure basic initialization order errors are caught.
 
 // RUN: %clangxx_asan %macos_min_target_10_11 -O0 %s %p/Helpers/initialization-bug-extra2.cc -o %t-INIT-ORDER-EXE
 // RUN: %env_asan_opts=check_initialization_order=true not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s
 
 // Do not test with optimization -- the error may be optimized away.
 
 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 // The test is expected to fail on OS X Yosemite and older
 // UNSUPPORTED: osx-no-ld64-live_support
 // UNSUPPORTED: ios
 
 #include <cstdio>
 
 // The structure of the test is:

test/asan/TestCases/intra-object-overflow.cc

 // RUN: %clangxx_asan -O0 -fsanitize-address-field-padding=1  %s -o %t
 // RUN: not %run %t 11 2>&1 | FileCheck %s
 // RUN: %run %t 10
 //
 // FIXME: fix 32-bits.
 // REQUIRES: asan-64-bits, shadow-scale-3
 // FIXME: Implement ASan intra-object padding in Clang's MS record layout
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 #include <stdio.h>
 #include <stdlib.h>
 class Foo {
  public:
   Foo() : pre1(1), pre2(2), post1(3), post2(4) {
   }
   virtual ~Foo() {
   }

test/asan/TestCases/log-path_test.cc

 // RUN: FileCheck %s --check-prefix=CHECK-LONG < %t.out
 
 // Run w/o errors should not produce any log.
 // RUN: rm -f %t.log.*
 // RUN: %env_asan_opts=log_path=%t.log  %run %t ARG ARG ARG
 // RUN: not cat %t.log.*
 
 // FIXME: log_path is not supported on Windows yet.
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   if (argc > 2) return 0;
   char *x = (char*)malloc(10);
   memset(x, 0, 10);
   int res = x[argc * 10];  // BOOOM
   free(x);
   return res;
 }
 // CHECK-ERROR: ERROR: AddressSanitizer
 // CHECK-INVALID: ERROR: Can't open file: /dev/null/INVALID
 // CHECK-LONG: ERROR: Path is too long: 01234

test/asan/TestCases/pass-object-byval.cc

 // Verify that objects passed by value get red zones and that the copy
 // constructor is called.
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --implicit-check-not \
 // RUN:     Assertion{{.*}}failed
 
 // ASan instrumentation can't insert red-zones around inalloca parameters.
-// XFAIL: win32 && asan-32-bits
+// XFAIL: windows-msvc && asan-32-bits
 
 #include <cassert>
 
 class A {
  public:
   A() : me(this) {}
   A(const A &other) : me(this) {
     for (int i = 0; i < 8; ++i) a[i] = other.a[i];

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: win32
+// XFAIL: windows-msvc
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 int main() {
   volatile char c = '0';
   volatile int x = 12;
   volatile float f = 1.239;

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: win32
+// XFAIL: windows-msvc
 
 #include <stdio.h>
 int main() {
 #ifdef _MSC_VER
   // FIXME: The test raises a dialog even though it's XFAILd.
   return 42;
 #endif
   volatile char c = '0';

test/asan/TestCases/printf-4.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: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-ON %s
 
 // FIXME: sprintf is not intercepted on Windows yet. But this test can
 // pass if sprintf calls memmove, which is intercepted, so we can't XFAIL it.
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <stdio.h>
 int main() {
   volatile char c = '0';
   volatile int x = 12;
   volatile float f = 1.239;
   volatile char s[] = "34";
   volatile char buf[2];

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: win32
+// XFAIL: windows-msvc
 
 #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";

test/asan/TestCases/printf-m.c

 // RUN: %clang_asan -O2 %s -o %t && %run %t
 
 // FIXME: printf is not intercepted on Windows yet.
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <stdio.h>
 
 int main() {
   char s[5] = {'w', 'o', 'r', 'l', 'd'};
   // Test that %m does not consume an argument. If it does, %s would apply to
   // the 5-character buffer, resulting in a stack-buffer-overflow report.
   printf("%m %s, %.5s\n", "hello", s);
   return 0;
 }

test/asan/TestCases/set_shadow_test.c

 // RUN: %clang_asan -O0 %s -o %t
 // RUN: %run %t 0x00 2>&1 | FileCheck %s -check-prefix=X00
 // RUN: not %run %t 0xf1 2>&1 | FileCheck %s -check-prefix=XF1
 // RUN: not %run %t 0xf2 2>&1 | FileCheck %s -check-prefix=XF2
 // RUN: not %run %t 0xf3 2>&1 | FileCheck %s -check-prefix=XF3
 // RUN: not %run %t 0xf5 2>&1 | FileCheck %s -check-prefix=XF5
 // RUN: not %run %t 0xf8 2>&1 | FileCheck %s -check-prefix=XF8
 
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 #include <assert.h>
 #include <sanitizer/asan_interface.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 
 void __asan_set_shadow_00(size_t addr, size_t size);

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
+// XFAIL: windows-msvc
 
 #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;
 }

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: win32
+// XFAIL: windows-msvc
 
 #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;
 }

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: win32
+// XFAIL: windows-msvc
 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
 int main(int argc, char **argv) {
   size_t size = 100;

test/asan/TestCases/strcat-overlap.cc

 // RUN: echo "interceptor_name:strcat" > %t.supp
 // RUN: %env_asan_opts=suppressions='"%t.supp"' %run %t
 
 // This test when run with suppressions invokes undefined
 // behavior which can cause all sorts of bad things to happen
 // depending on how strcat() is implemented. For now only run
 // on platforms where we know the test passes.
 // REQUIRES: x86_64h-darwin || x86_64-darwin || i386-darwin || x86_64-linux || i386-linux
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // UNSUPPORTED: android
 
 #include <string.h>
 
 
 // Don't inline function otherwise stacktrace changes.
 __attribute__((noinline)) void bad_function() {
   char buffer[] = "hello\0XXX";

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: win32
+// XFAIL: windows-msvc
 
 #include <assert.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
 
 int main(int argc, char **argv) {

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: win32
+// XFAIL: windows-msvc
 
 #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)

test/asan/TestCases/suppressions-exec-relative-location.cc

 // RUN: %env_asan_opts=suppressions='"/absolute/path"' not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
 
 // Test that we reject directory as filename.
 // RUN: %env_asan_opts=suppressions='"folder/only/"' not %run %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=CHECK-WRONG-FILE-NAME %s
 
 // XFAIL: android
-// XFAIL: win32
+// XFAIL: windows-msvc
 // UNSUPPORTED: ios
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 void crash_function() {
   char *a = (char *)malloc(6);

test/asan/TestCases/suppressions-function.cc

 // Check that without suppressions, we catch the issue.
 // RUN: %clangxx_asan -O0 %s -o %t
 // RUN: not %run %t 2>&1 | FileCheck --check-prefix=CHECK-CRASH %s
 
 // RUN: echo "interceptor_via_fun:crash_function" > %t.supp
 // RUN: %clangxx_asan -O0 %s -o %t && %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 // RUN: %clangxx_asan -O3 %s -o %t && %env_asan_opts=suppressions='"%t.supp"' %run %t 2>&1 | FileCheck --check-prefix=CHECK-IGNORE %s
 
 // FIXME: Windows symbolizer needs work to make this pass.
-// XFAIL: android,win32
+// XFAIL: android,windows-msvc
 // UNSUPPORTED: ios
 
 // FIXME: atos does not work for inlined functions, yet llvm-symbolizer
 // does not always work with debug info on Darwin.
 // UNSUPPORTED: darwin
 
 #include <stdio.h>
 #include <stdlib.h>

test/asan/TestCases/time_interceptor.cc

 // 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: win32
+// XFAIL: windows-msvc
 
 #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));  // NOLINT
   // CHECK: use-after-free
   // Regression check for
   // https://code.google.com/p/address-sanitizer/issues/detail?id=321
   // CHECK: SUMMARY
   return 0;
 }

test/asan/TestCases/verbose-log-path_test.cc

 // RUN: rm -rf %t-dir && mkdir -p %t-dir
 // RUN: %clangxx_asan %s -o %t-dir/verbose-log-path_test-binary
 
 // The glob below requires bash.
 // REQUIRES: shell
 
 // Good log_path.
 // RUN: rm -f %t-dir/asan.log.*
 // RUN: %env_asan_opts=log_path=%t-dir/asan.log:log_exe_name=1 not %run %t-dir/verbose-log-path_test-binary 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t-dir/asan.log.verbose-log-path_test-binary.*
 
 // FIXME: only FreeBSD, NetBSD and Linux have verbose log paths now.
-// XFAIL: win32,android
+// XFAIL: windows-msvc,android
 // UNSUPPORTED: ios
 
 #include <stdlib.h>
 #include <string.h>
 int main(int argc, char **argv) {
   if (argc > 2) return 0;
   char *x = (char*)malloc(10);
   memset(x, 0, 10);
   int res = x[argc * 10];  // BOOOM
   free(x);
   return res;
 }
 // CHECK-ERROR: ERROR: AddressSanitizer

test/cfi/bad-split.cpp

 // GlobalSplit used to lose type metadata for classes with virtual bases but no virtual methods.
 // RUN: %clangxx_cfi -o %t1 %s && %run %t1
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 struct Z {
 };
 
 struct ZZ : public virtual Z {
 };
 
 struct A : public ZZ {

test/cfi/cross-dso-diagnostic.cpp

 // Check that cross-DSO diagnostics print the names of both modules
 
 // RUN: %clangxx_cfi_diag -g -DSHARED_LIB -fPIC -shared -o %dynamiclib %s %ld_flags_rpath_so
 // RUN: %clangxx_cfi_diag -g -o %t_exe_suffix %s %ld_flags_rpath_exe
 // RUN: %t_exe_suffix 2>&1 | FileCheck -DDSONAME=%xdynamiclib_namespec %s
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // REQUIRES: cxxabi
 
 #include <dlfcn.h>
 #include <stdio.h>
 
 struct S1 {
   virtual void f1();
 };

test/cfi/mfcall.cpp

-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 // RUN: %clangxx_cfi -o %t %s
 // RUN: %expect_crash %run %t a
 // RUN: %expect_crash %run %t b
 // RUN: %expect_crash %run %t c
 // RUN: %expect_crash %run %t d
 // RUN: %expect_crash %run %t e
 // RUN: %run %t f

test/cfi/target_uninstrumented.cpp

 // RUN: %clangxx -g -DSHARED_LIB %s -fPIC -shared -o %dynamiclib %ld_flags_rpath_so
 // RUN: %clangxx_cfi_diag -g %s -o %t %ld_flags_rpath_exe
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <stdio.h>
 #include <string.h>
 
 struct A {
   virtual void f();
 };
 

test/cfi/two-vcalls.cpp

 // RUN: %clangxx_cfi_diag -o %t %s
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // This test checks that we don't generate two type checks,
 // if two virtual calls are in the same function.
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // REQUIRES: cxxabi
 
 // TODO(krasin): implement the optimization to not emit two type checks.
 // XFAIL: *
 #include <stdio.h>
 
 class Base {
  public:

test/msan/strndup.cc

 // RUN: %clangxx_msan %s -o %t && not %run %t 2>&1 | FileCheck --check-prefix=ON %s
 // RUN: %clangxx_msan %s -o %t && MSAN_OPTIONS=intercept_strndup=0 %run %t 2>&1 | FileCheck --check-prefix=OFF --allow-empty %s
 
 // When built as C on Linux, strndup is transformed to __strndup.
 // RUN: %clangxx_msan -O3 -xc %s -o %t && not %run %t 2>&1 | FileCheck --check-prefix=ON %s
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sanitizer/msan_interface.h>
 
 int main(int argc, char **argv) {
   char kString[4] = "abc";

test/sanitizer_common/TestCases/allocator_returns_null.cc

 // RUN: %env_tool_opts=allocator_may_return_null=1 not %run %t new 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH-OOM
 // RUN: %env_tool_opts=allocator_may_return_null=0 not %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnCRASH
 // RUN: %env_tool_opts=allocator_may_return_null=1     %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-NULL
 
 // TODO(alekseyshl): win32 is disabled due to failing errno tests, fix it there.
-// UNSUPPORTED: ubsan, win32
+// UNSUPPORTED: ubsan, windows-msvc
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits>
 #include <new>

test/sanitizer_common/TestCases/malloc_hook.cc

 // RUN: %clangxx -O2 %s -o %t && %run %t 2>&1 | FileCheck %s
 
 // Malloc/free hooks are not supported on Windows.
-// XFAIL: win32
+// XFAIL: windows-msvc
 // XFAIL: ubsan
 
 #include <stdlib.h>
 #include <unistd.h>
 #include <sanitizer/allocator_interface.h>
 
 extern "C" {
 const volatile void *global_ptr;

test/sanitizer_common/TestCases/strcasestr.c

 // RUN: %clang %s -o %t && %run %t 2>&1
 
 // There's no interceptor for strcasestr on Windows
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 #define _GNU_SOURCE
 #include <assert.h>
 #include <string.h>
 int main(int argc, char **argv) {
   char *r = 0;
   char s1[] = "aB";
   char s2[] = "b";
   r = strcasestr(s1, s2);
   assert(r == s1 + 1);
   return 0;
 }

test/ubsan/TestCases/Misc/enum.cpp

 // RUN: %clangxx -fsanitize=enum %s -O3 -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-PLAIN
 // RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E" %s -O3 -o %t && %run %t
 // RUN: %clangxx -fsanitize=enum -std=c++11 -DE="class E : bool" %s -O3 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-BOOL
 
 // FIXME: UBSan fails to add the correct instrumentation code for some reason on
 // Windows.
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 enum E { a = 1 } e;
 #undef E
 
 int main(int argc, char **argv) {
   // memset(&e, 0xff, sizeof(e));
   for (unsigned char *p = (unsigned char*)&e; p != (unsigned char*)(&e + 1); ++p)
     *p = 0xff;
 
   // CHECK-PLAIN: error: load of value 4294967295, which is not a valid value for type 'enum E'
   // FIXME: Support marshalling and display of enum class values.
   // CHECK-BOOL: error: load of value <unknown>, which is not a valid value for type 'enum E'
   return (int)e != -1;
 }

test/ubsan/TestCases/Misc/log-path_test.cc

 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %t.log.*
 
 // Run w/o errors should not produce any log.
 // RUN: rm -f %t.log.*
 // RUN: %env_ubsan_opts=log_path='"%t.log"'  %run %t 4
 // RUN: not cat %t.log.*
 
 // FIXME: log_path is not supported on Windows yet.
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 #include <stdio.h>
 #include <stdlib.h>
 int main(int argc, char *argv[]) {
   double a = atof(argv[1]);
   unsigned int ai = (unsigned int) a;
   printf("%f %u\n", a, ai);
   return 0;
 }
 
 // CHECK-ERROR: runtime error: -4 is outside the range of representable values of type 'unsigned int'
 

test/ubsan/TestCases/Misc/monitor.cpp

 // RUN: %clangxx -w -fsanitize=bool %s -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // __ubsan_on_report is not defined as weak. Redefining it here isn't supported
 // on Windows.
 //
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // Linkage issue
 // XFAIL: openbsd
 
 #include <cstdio>
 
 extern "C" {
 void __ubsan_get_current_report_data(const char **OutIssueKind,
                                      const char **OutMessage,

test/ubsan/TestCases/TypeCheck/Function/function.cpp

 // RUN: %clangxx -std=c++17 -fsanitize=function %s -O3 -g -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 // Verify that we can disable symbolization if needed:
 // RUN: %env_ubsan_opts=symbolize=0 %run %t 2>&1 | FileCheck %s --check-prefix=NOSYM
-// XFAIL: win32,win64
+// XFAIL: windows-msvc
 // Unsupported function flag
 // UNSUPPORTED: openbsd
 
 #include <stdint.h>
 
 void f() {}
 
 void g(int x) {}

test/ubsan/TestCases/TypeCheck/PR33221.cpp

 // RUN: %clangxx -frtti -fsanitize=null,vptr -g %s -O3 -o %t
 // RUN: %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <string.h>
 
 class Base {
 public:
   int i;
   virtual void print() {}
 };

test/ubsan/TestCases/TypeCheck/vptr-corrupted-vtable-itanium.cpp

 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr,null -g %s -O3 -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-CORRUPTED-VTABLE --strict-whitespace
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // REQUIRES: stable-runtime, cxxabi
 #include <cstddef>
 
 #include <typeinfo>
 
 struct S {
   S() {}
   ~S() {}

test/ubsan/TestCases/TypeCheck/vptr-non-unique-typeinfo.cpp

 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -I%p/Helpers -g %s -fPIC -shared -o %dynamiclib -DBUILD_SO %ld_flags_rpath_so
 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr -I%p/Helpers -g %s -O3 -o %t %ld_flags_rpath_exe
 // RUN: %run %t
 //
 // REQUIRES: cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 struct X {
   virtual ~X() {}
 };
 X *libCall();
 
 #ifdef BUILD_SO
 

test/ubsan/TestCases/TypeCheck/vptr-virtual-base-construction.cpp

 // RUN: %clangxx -frtti -fsanitize=vptr -fno-sanitize-recover=vptr %s -o %t
 // RUN: %run %t
 
 // REQUIRES: cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 int volatile n;
 
 struct A { virtual ~A() {} };
 struct B: virtual A {};
 struct C: virtual A { ~C() { n = 0; } };
 struct D: virtual B, virtual C {};
 
 int main() { delete new D; }

test/ubsan/TestCases/TypeCheck/vptr-virtual-base.cpp

 // RUN: %clangxx -frtti -fsanitize=null,vptr -fno-sanitize-recover=vptr -g %s -O3 -o %t
 // RUN: not %run %t 2>&1 | FileCheck %s
 
 // REQUIRES: cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 struct S { virtual int f() { return 0; } };
 struct T : virtual S {};
 
 struct Foo { virtual int f() { return 0; } };
 
 int main(int argc, char **argv) {
   Foo foo;
   T *t = (T*)&foo;
   S *s = t;
   // CHECK: vptr-virtual-base.cpp:[[@LINE-1]]:10: runtime error: cast to virtual base of address [[PTR:0x[0-9a-f]*]] which does not point to an object of type 'T'
   // CHECK-NEXT: [[PTR]]: note: object is of type 'Foo'
   return s->f();
 }

test/ubsan/TestCases/TypeCheck/vptr.cpp

 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t cV
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t oU
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.supp"' %run %t dT
 
 // RUN: echo "vptr_check:S" > %t.loc-supp
 // RUN: %env_ubsan_opts=halt_on_error=1:suppressions='"%t.loc-supp"' not %run %t x- 2>&1 | FileCheck %s --check-prefix=CHECK-LOC-SUPPRESS
 
 // REQUIRES: stable-runtime, cxxabi
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 // Suppressions file not pushed to the device.
 // UNSUPPORTED: android
 // Compilation error
 // UNSUPPORTED: openbsd
 #include <new>
 #include <typeinfo>
 #include <assert.h>
 #include <stdio.h>