[Support] Avoid normalization in sys::getDefaultTargetTriple

[phosek]

Summary

The return value of sys::getDefaultTargetTriple, which is derived from
-DLLVM_DEFAULT_TRIPLE, is used to construct tool names, default target,
and in the future also to control the search path directly; as such it
should be used textually, without interpretation by LLVM.

Normalization of this value may lead to unexpected results, for example
if we configure LLVM with -DLLVM_DEFAULT_TARGET_TRIPLE=x86_64-linux-gnu,
normalization will transform that value to x86_64--linux-gnu. Driver will
use that value to search for tools prefixed with x86_64--linux-gnu- which
may be confusing. This is also inconsistent with the behavior of the
--target flag which is taken as-is without any normalization and overrides
the value of LLVM_DEFAULT_TARGET_TRIPLE.

Users of sys::getDefaultTargetTriple already perform their own
normalization as needed, so this change shouldn't impact existing logic.

[delcypher]

I'm not familiar with this code but if I'm reading the patch correctly, then the commit message omits the fact that it changes the windows target triple from having a win32 suffix to windows-msvc suffix. I'm not sure what the implications are here but the fact you've done this is probably worth mentioning in the commit message.

[phosek]

In D47153#1106780, @delcypher wrote:

I'm not familiar with this code but if I'm reading the patch correctly, then the commit message omits the fact that it changes he windows target triple from having a win32 suffix to windows-msvc suffix. I'm not sure what the implications are here but the fact you've done this is probably worth mentioning in the commit message.

Done. I've also tested this change on Windows and this seems to be passing now so should be ready for re-land.

[phosek]

In D47153#1107469, @phosek wrote:

Done. I've also tested this change on Windows and this seems to be passing now so should be ready for re-land.

Spoke too early, the following tests are still failing:

Clang :: Analysis/cxx-crashes.cpp
Clang :: CodeGen/2007-06-18-SextAttrAggregate.c
Clang :: CodeGen/2008-12-23-AsmIntPointerTie.c
Clang :: CodeGen/statements.c
Clang :: CodeGenCXX/2005-01-03-StaticInitializers.cpp
Clang :: CodeGenCXX/reinterpret-cast.cpp
Clang :: CodeGenCXX/vtable-debug-info.cpp
Clang :: Driver/coverage_no_integrated_as.c
Clang :: Driver/inhibit-downstream-commands.c
Clang :: Driver/linker-opts.c
Clang :: Driver/no-integrated-as.s
Clang :: Driver/nostdincxx.cpp
Clang :: Sema/array-init.c
Clang :: Sema/compound-literal.c
Clang :: SemaCXX/cstyle-cast.cpp
Clang :: SemaCXX/functional-cast.cpp
Clang :: SemaObjC/nonnull.m
Clang :: SemaObjCXX/pointer-to-objc-pointer-conv.mm

[delcypher]

In D47153#1107469, @phosek wrote:

In D47153#1106780, @delcypher wrote:

I'm not familiar with this code but if I'm reading the patch correctly, then the commit message omits the fact that it changes he windows target triple from having a win32 suffix to windows-msvc suffix. I'm not sure what the implications are here but the fact you've done this is probably worth mentioning in the commit message.

Done. I've also tested this change on Windows and this seems to be passing now so should be ready for re-land.

Thanks. This code really isn't my area though so you should wait for a LGTM from one of your reviewers.

llvm/utils/lit/lit/llvm/config.py

252–253

This comment probably needs updating. s/win32/windows/

[phosek]

llvm/utils/lit/lit/llvm/config.py

252–253

@rnk I assume this should only be the case when the triple is *-windows-msvc, not *-windows-gnu, but what if user omits the environment? Shall we just bail out or pick some default?

[rnk]

I think we can probably split this patch up to reduce the risk of breaking things. I think if you revert the config-ix.cmake change and just move triple normalization from LLVM to clang, everything should keep working. LLVM tools like llc might start to break in interesting ways, though, since they won't do the normalization that clang is doing. If check-llvm passes, though, I'm happy.

The config-ix.cmake and %itanium_abi_triple can be a follow-up.

[phosek]

In D47153#1111541, @rnk wrote:

I think we can probably split this patch up to reduce the risk of breaking things. I think if you revert the config-ix.cmake change and just move triple normalization from LLVM to clang, everything should keep working. LLVM tools like llc might start to break in interesting ways, though, since they won't do the normalization that clang is doing. If check-llvm passes, though, I'm happy.

The config-ix.cmake and %itanium_abi_triple can be a follow-up.

All the tests seem to be passing now, but the patch is rather large now. I tried splitting up the the triple normalization and everything seems to be still passing so I'm fine landing those two parts separately.

[rnk]

lgtm

clang/lib/Frontend/CompilerInvocation.cpp

if (EABIVersion == llvm::EABI::Unknown)
                                                 << Value;
     else
       Opts.EABIVersion = EABIVersion;
   }
   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
   Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
   Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
-  Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
+  Opts.Triple = Args.getLastArgValue(OPT_triple);
   // Use the default target triple if unspecified.
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
+  Opts.Triple = llvm::Triple::normalize(Opts.Triple);
   Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
   Opts.ForceEnableInt128 = Args.hasArg(OPT_fforce_enable_int128);
   Opts.NVPTXUseShortPointers = Args.hasFlag(
       options::OPT_fcuda_short_ptr, options::OPT_fno_cuda_short_ptr, false);
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         const char *const *ArgBegin,

clang/test/CodeGen/2007-06-18-SextAttrAggregate.c

 // RUN: %clang_cc1 %s -o - -emit-llvm | FileCheck %s
-// XFAIL: aarch64, arm64, x86_64-pc-win32, x86_64-w64-mingw32
+// XFAIL: aarch64, arm64, x86_64-pc-windows-msvc, x86_64-w64-windows-gnu
 
 // PR1513
 
 // AArch64 ABI actually requires the reverse of what this is testing: the callee
 // does any extensions and remaining bits are unspecified.
 
 // Win64 ABI does expect extensions for type smaller than 64bits.
 

clang/test/CodeGenCXX/vtable-debug-info.cpp

 // RUN: %clang -emit-llvm -S -g %s -o /dev/null
 // Radar 8730409
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 // FIXME: This test crashes on *-pc-win32
 // for lack of debugging support on -integrated-as (MCCOFF).
 #ifdef _MSC_VER
 
 #error this test must xfail
 
 #else

clang/test/Driver/coverage_no_integrated_as.c

 // REQUIRES: clang-driver
-// XFAIL: win32,win64
+// XFAIL: windows-msvc
 
 // RUN: %clang -### -S -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s
 // RUN: %clang -### -S -fprofile-arcs -no-integrated-as %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s
 // RUN: %clang -### -c -fprofile-arcs %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s
 // RUN: %clang -### -c -fprofile-arcs -no-integrated-as %s 2>&1 | FileCheck -check-prefix=CHECK-GCNO-DEFAULT-LOCATION %s
 
 // RUN: %clang -### -S -fprofile-arcs %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s
 // RUN: %clang -### -S -fprofile-arcs -no-integrated-as %s -o /foo/bar.o 2>&1 | FileCheck -check-prefix=CHECK-GCNO-LOCATION %s

clang/test/Driver/inhibit-downstream-commands.c

 // RUN: not %clang -no-integrated-as %s 2>&1 | FileCheck %s
 // CHECK: error: unknown type name 'invalid'
 // CHECK-NOT: clang: error: assembler command failed 
 // CHECK-NOT: clang: error: linker command failed
-// XFAIL: win32
+// XFAIL: windows-msvc
 invalid C code!

clang/test/Driver/linker-opts.c

 // RUN: rm -rf %t
 // RUN: mkdir %t
 //
 // RUN: env LIBRARY_PATH=%t/test1 %clang -x c %s -### 2>&1 | FileCheck %s
 // CHECK: "-L{{.*}}/test1"
 
 // GCC driver is used as linker on cygming. It should be aware of LIBRARY_PATH.
-// XFAIL: win32
+// XFAIL: windows-msvc
 // REQUIRES: clang-driver
 // REQUIRES: native
 
 // Make sure that LIBRARY_PATH works for both i386 and x86_64 on Darwin.
 // RUN: env LIBRARY_PATH=%t/test1 %clang -target x86_64-apple-darwin %s -### 2>&1 | FileCheck %s
 // RUN: env LIBRARY_PATH=%t/test1 %clang -target i386-apple-darwin  %s -### 2>&1 | FileCheck %s
 //
 // Make sure that we don't warn on unused compiler arguments.
 // RUN: %clang -Xclang -I. -x c %s -c -o %t/tmp.o
 // RUN: %clang -Xclang -I. %t/tmp.o -o %t/tmp -### 2>&1 | FileCheck %s --check-prefix=NO-UNUSED
 // NO-UNUSED-NOT: warning:{{.*}}unused
 //
 // Make sure that we do warn in other cases.
 // RUN: %clang %s -lfoo -c -o %t/tmp2.o -### 2>&1 | FileCheck %s --check-prefix=UNUSED
 // UNUSED: warning:{{.*}}unused

clang/test/Driver/no-integrated-as.s

 ; RUN: %clang -### -no-integrated-as -c %s 2>&1 | FileCheck %s -check-prefix IAS
 ; Windows doesn't support no-integrated-as
-; XFAIL: win32,win64
+; XFAIL: windows-msvc
 ;
 ; Make sure the current file's filename appears in the output.
 ; We can't generically match on the assembler name, so we just make sure
 ; the filename is in the output.
 ; IAS: no-integrated-as.s

clang/test/Lexer/cross-windows-on-linux.cpp

 // RUN: not %clang_cc1 -fsyntax-only -triple i686-win32 %s 2>&1 | FileCheck %s
 
 #include "Inputs\success.h"
 
 // CHECK: error: 'Inputs\success.h' file not found
 // CHECK: #include "Inputs\success.h"
 // CHECK:          ^
 
 // expected to fail on windows as the inclusion would succeed and the
 // compilation will fail due to the '#error success'.
-// XFAIL: win32
+// XFAIL: windows-msvc
 
 // This test may or may not fail since 'Inputs\success.h' is passed
 // to Win32 APIs on Windows.
 // REQUIRES: disabled

clang/test/lit.cfg.py

 if is_filesystem_case_insensitive():
     config.available_features.add('case-insensitive-filesystem')
 
 # Tests that require the /dev/fd filesystem.
 if os.path.exists('/dev/fd/0') and sys.platform not in ['cygwin']:
     config.available_features.add('dev-fd-fs')
 
 # Not set on native MS environment.
-if not re.match(r'.*-win32$', config.target_triple):
+if not re.match(r'.*-(win32|windows-msvc)$', config.target_triple):
     config.available_features.add('non-ms-sdk')
 
 # Not set on native PS4 environment.
 if not re.match(r'.*-scei-ps4', config.target_triple):
     config.available_features.add('non-ps4-sdk')
 
 # [PR8833] LLP64-incompatible tests
-if not re.match(r'^x86_64.*-(win32|mingw32|windows-gnu)$', config.target_triple):
+if not re.match(r'^x86_64.*-(win32|mingw32|windows-msvc|windows-gnu)$', config.target_triple):
     config.available_features.add('LP64')
 
 # [PR12920] "clang-driver" -- set if gcc driver is not used.
 if not re.match(r'.*-(cygwin)$', config.target_triple):
     config.available_features.add('clang-driver')
 
 # [PR18856] Depends to remove opened file. On win32, a file could be removed
 # only if all handles were closed.

compiler-rt/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,armv7l-unknown-linux-gnueabihf
+// UNSUPPORTED: windows-msvc,s390,armv7l-unknown-linux-gnueabihf
 
 #include <string.h>
 
 char kString[] = "foo";
 
 int main(int argc, char **argv) {
   char *copy = strndup(kString, 2);
   int x = copy[2 + argc];  // BOOM

compiler-rt/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,armv7l-unknown-linux-gnueabihf
+// UNSUPPORTED: windows-msvc,s390,armv7l-unknown-linux-gnueabihf
 
 #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;
-}
+}
 

compiler-rt/test/asan/TestCases/allocator_returns_null.cc

 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH
 // RUN: %env_asan_opts=allocator_may_return_null=1 not %run %t new 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH-OOM
 // RUN: %env_asan_opts=allocator_may_return_null=0 not %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnCRASH
 // RUN: %env_asan_opts=allocator_may_return_null=1     %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnNULL
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits>
 #include <new>

compiler-rt/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
 }

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: 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);

compiler-rt/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:

compiler-rt/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() {
   }

compiler-rt/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

compiler-rt/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];

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: 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;

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: 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';

compiler-rt/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];

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: 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";

compiler-rt/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;
 }

compiler-rt/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);

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: 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;
 }

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: 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;
 }

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: 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;

compiler-rt/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";

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: 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) {

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: 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)

compiler-rt/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);

compiler-rt/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;
 }

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

 // RUN: %clangxx_asan %s -o %T/verbose-log-path_test-binary
 
 // The glob below requires bash.
 // REQUIRES: shell
 
 // Good log_path.
 // RUN: rm -f %T/asan.log.*
 // RUN: %env_asan_opts=log_path=%T/asan.log:log_exe_name=1 not %run %T/verbose-log-path_test-binary 2> %t.out
 // RUN: FileCheck %s --check-prefix=CHECK-ERROR < %T/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

compiler-rt/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 {

compiler-rt/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();
 };
 

compiler-rt/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:

compiler-rt/test/msan/allocator_returns_null.cc

 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH
 // RUN: MSAN_OPTIONS=allocator_may_return_null=1 not %run %t new 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nCRASH
 // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnCRASH
 // RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnNULL
 
-// UNSUPPORTED: win32
+// UNSUPPORTED: windows-msvc
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits>
 #include <new>

compiler-rt/test/msan/pvalloc.cc

 // RUN: %clangxx_msan -O0 %s -o %t
 // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t m1 2>&1 | FileCheck %s
 // RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t m1 2>&1
 // RUN: MSAN_OPTIONS=allocator_may_return_null=0 not %run %t psm1 2>&1 | FileCheck %s
 // RUN: MSAN_OPTIONS=allocator_may_return_null=1     %run %t psm1 2>&1
 
 // pvalloc is Linux only
-// UNSUPPORTED: win32, freebsd, netbsd
+// UNSUPPORTED: windows-msvc, freebsd, netbsd
 
 // Checks that pvalloc overflows are caught. If the allocator is allowed to
 // return null, the errno should be set to ENOMEM.
 
 #include <assert.h>
 #include <errno.h>
 #include <malloc.h>
 #include <stdint.h>

compiler-rt/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";

compiler-rt/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;

compiler-rt/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;
 }

compiler-rt/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;
 }

compiler-rt/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'
 

compiler-rt/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
 
 #include <stdint.h>
 
 void f() {}
 
 void g(int x) {}
 
 void make_valid_call() {

compiler-rt/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() {}
 };

compiler-rt/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() {}

compiler-rt/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
 

compiler-rt/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; }

compiler-rt/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();
 }

compiler-rt/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
 #include <new>
 #include <typeinfo>
 #include <assert.h>
 #include <stdio.h>
 
 struct S {

llvm/cmake/modules/GetHostTriple.cmake

 # Returns the host triple.
 # Invokes config.guess
 
 function( get_host_triple var )
   if( MSVC )
     if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
-      set( value "x86_64-pc-win32" )
+      set( value "x86_64-pc-windows-msvc" )
     else()
-      set( value "i686-pc-win32" )
+      set( value "i686-pc-windows-msvc" )
     endif()
   elseif( MINGW AND NOT MSYS )
     if( CMAKE_SIZEOF_VOID_P EQUAL 8 )
-      set( value "x86_64-w64-mingw32" )
+      set( value "x86_64-w64-windows-gnu" )
     else()
-      set( value "i686-pc-mingw32" )
+      set( value "i686-pc-windows-gnu" )
     endif()
   else( MSVC )
     set(config_guess ${LLVM_MAIN_SRC_DIR}/cmake/config.guess)
     execute_process(COMMAND sh ${config_guess}
       RESULT_VARIABLE TT_RV
       OUTPUT_VARIABLE TT_OUT
       OUTPUT_STRIP_TRAILING_WHITESPACE)
     if( NOT TT_RV EQUAL 0 )
       message(FATAL_ERROR "Failed to execute ${config_guess}")
     endif( NOT TT_RV EQUAL 0 )
     set( value ${TT_OUT} )
   endif( MSVC )
   set( ${var} ${value} PARENT_SCOPE )
 endfunction( get_host_triple var )

llvm/lib/Support/Unix/Host.inc

std::string sys::getDefaultTargetTriple() {
 
   // Override the default target with an environment variable named by
   // LLVM_TARGET_TRIPLE_ENV.
 #if defined(LLVM_TARGET_TRIPLE_ENV)
   if (const char *EnvTriple = std::getenv(LLVM_TARGET_TRIPLE_ENV))
     TargetTripleString = EnvTriple;
 #endif
 
-  return Triple::normalize(TargetTripleString);
+  return TargetTripleString;
 }

llvm/lib/Support/Windows/Host.inc

std::string sys::getDefaultTargetTriple() {
   const char *Triple = LLVM_DEFAULT_TARGET_TRIPLE;
 
   // Override the default target with an environment variable named by LLVM_TARGET_TRIPLE_ENV.
 #if defined(LLVM_TARGET_TRIPLE_ENV)
   if (const char *EnvTriple = std::getenv(LLVM_TARGET_TRIPLE_ENV))
     Triple = EnvTriple;
 #endif
 
-  return Triple::normalize(Triple);
+  return Triple;
 }

llvm/test/lit.cfg.py

 # Windows.  FIXME: the process target triple should be used here, but this is
 # difficult to obtain on Windows.
 if re.search(r'cygwin|mingw32|windows-gnu|windows-msvc|win32', config.host_triple):
     lli_args = ['-mtriple=' + config.host_triple + '-elf']
 
 llc_args = []
 
 # Similarly, have a macro to use llc with DWARF even when the host is win32.
-if re.search(r'win32', config.target_triple):
+if re.search(r'windows-msvc', config.target_triple):
     llc_args = [' -mtriple=' +
-                config.target_triple.replace('-win32', '-mingw32')]
+                config.target_triple.replace('-msvc', '-gnu')]
 
 # Provide the path to asan runtime lib if available. On darwin, this lib needs
 # to be loaded via DYLD_INSERT_LIBRARIES before libLTO.dylib in case the files
 # to be linked contain instrumented sanitizer code.
 ld64_cmd = config.ld64_executable
 asan_rtlib = get_asan_rtlib()
 if asan_rtlib:
     ld64_cmd = 'DYLD_INSERT_LIBRARIES={} {}'.format(asan_rtlib, ld64_cmd)

llvm/utils/lit/lit/llvm/config.py

def __init__(self, lit_config, config):
         if target_triple:
             if re.match(r'^x86_64.*-apple', target_triple):
                 host_cxx = getattr(config, 'host_cxx', None)
                 if 'address' in sanitizers and self.get_clang_has_lsan(host_cxx, target_triple):
                     self.with_environment(
                         'ASAN_OPTIONS', 'detect_leaks=1', append_path=True)
             if re.match(r'^x86_64.*-linux', target_triple):
                 features.add('x86_64-linux')
-            if re.match(r'.*-win32$', target_triple):
+            if re.match(r'.*-windows-msvc$', target_triple):
                 features.add('target-windows')
 
         use_gmalloc = lit_config.params.get('use_gmalloc', None)
         if lit.util.pythonize_bool(use_gmalloc):
             # Allow use of an explicit path for gmalloc library.
             # Will default to '/usr/lib/libgmalloc.dylib' if not set.
             gmalloc_path_str = lit_config.params.get('gmalloc_path',
                                                      '/usr/lib/libgmalloc.dylib')
def get_clang_has_lsan(self, clang, triple):
 
         return False
 
     def make_itanium_abi_triple(self, triple):
         m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
         if not m:
             self.lit_config.fatal(
                 "Could not turn '%s' into Itanium ABI triple" % triple)
-        if m.group(3).lower() != 'win32':
-            # All non-win32 triples use the Itanium ABI.
+        if m.group(3).lower() != 'windows':
+            # All non-windows triples use the Itanium ABI.
             return triple
-        return m.group(1) + '-' + m.group(2) + '-mingw32'
+        return m.group(1) + '-' + m.group(2) + '-' + m.group(3) + '-gnu'
 
     def make_msabi_triple(self, triple):
         m = re.match(r'(\w+)-(\w+)-(\w+)', triple)
         if not m:
             self.lit_config.fatal(
                 "Could not turn '%s' into MS ABI triple" % triple)
         isa = m.group(1).lower()
         vendor = m.group(2).lower()
         os = m.group(3).lower()
-        if os == 'win32':
-            # If the OS is win32, we're done.
+        if os == 'windows' and re.match(r'.*-msvc$', triple):
+            # If the OS is windows and environment is msvc, we're done.
             return triple
         if isa.startswith('x86') or isa == 'amd64' or re.match(r'i\d86', isa):
             # For x86 ISAs, adjust the OS.
-            return isa + '-' + vendor + '-win32'
-        # -win32 is not supported for non-x86 targets; use a default.
-        return 'i686-pc-win32'
+            return isa + '-' + vendor + '-windows-msvc'
+        # -msvc is not supported for non-x86 targets; use a default.
+        return 'i686-pc-windows-msvc'
 
     def add_tool_substitutions(self, tools, search_dirs=None):
         if not search_dirs:
             search_dirs = [self.config.llvm_tools_dir]
 
         if lit.util.is_string(search_dirs):
             search_dirs = [search_dirs]