swiftlang · compnerd · Apr 18, 2018 · Apr 16, 2018
diff --git a/lib/Driver/Driver.cpp b/lib/Driver/Driver.cpp
@@ -223,7 +223,9 @@ Driver::buildToolChain(const llvm::opt::InputArgList &ArgList) {
   case llvm::Triple::FreeBSD:
     return llvm::make_unique<toolchains::GenericUnix>(*this, target);
   case llvm::Triple::Win32:
-    return llvm::make_unique<toolchains::Cygwin>(*this, target);
+    if (target.isWindowsCygwinEnvironment())
+      return llvm::make_unique<toolchains::Cygwin>(*this, target);
+    return llvm::make_unique<toolchains::Windows>(*this, target);
   case llvm::Triple::Haiku:
     return llvm::make_unique<toolchains::GenericUnix>(*this, target);
   default:

diff --git a/lib/Driver/ToolChains.cpp b/lib/Driver/ToolChains.cpp
@@ -1138,6 +1138,13 @@ getSanitizerRuntimeLibNameForDarwin(StringRef Sanitizer,
       + (shared ? "_dynamic.dylib" : ".a")).str();
 }
 
+static std::string
+getSanitizerRuntimeLibNameForWindows(StringRef Sanitizer,
+                                     const llvm::Triple &Triple) {
+  return (Twine("clang_rt.") + Sanitizer + "-" + Triple.getArchName() + ".lib")
+      .str();
+}
+
 static std::string
 getSanitizerRuntimeLibNameForLinux(StringRef Sanitizer, const llvm::Triple &Triple) {
   return (Twine("libclang_rt.") + Sanitizer + "-" +
@@ -1154,6 +1161,17 @@ bool toolchains::Darwin::sanitizerRuntimeLibExists(
   return llvm::sys::fs::exists(sanitizerLibPath.str());
 }
 
+bool toolchains::Windows::sanitizerRuntimeLibExists(const ArgList &args,
+                                                    StringRef sanitizer,
+                                                    bool shared) const {
+  SmallString<128> sanitizerLibPath;
+  getClangLibraryPath(*this, args, sanitizerLibPath);
+  llvm::sys::path::append(
+      sanitizerLibPath,
+      getSanitizerRuntimeLibNameForWindows(sanitizer, this->getTriple()));
+  return llvm::sys::fs::exists(sanitizerLibPath.str());
+}
+
 bool toolchains::GenericUnix::sanitizerRuntimeLibExists(
     const ArgList &args, StringRef sanitizer, bool shared) const {
   SmallString<128> sanitizerLibPath;
@@ -1196,16 +1214,22 @@ addLinkRuntimeLibForDarwin(const ArgList &Args, ArgStringList &Arguments,
   }
 }
 
+static void addLinkRuntimeLibForWindows(const ArgList &Args,
+                                        ArgStringList &Arguments,
+                                        StringRef WindowsLibName,
+                                        const ToolChain &TC) {
+  SmallString<128> P;
+  getClangLibraryPath(TC, Args, P);
+  llvm::sys::path::append(P, WindowsLibName);
+  Arguments.push_back(Args.MakeArgString(P));
+}
+
 static void
 addLinkRuntimeLibForLinux(const ArgList &Args, ArgStringList &Arguments,
                            StringRef LinuxLibName,
                            const ToolChain &TC) {
-  SmallString<128> Dir;
-  getRuntimeLibraryPath(Dir, Args, TC, /*Shared=*/ true);
-  // Remove platform name.
-  llvm::sys::path::remove_filename(Dir);
-  llvm::sys::path::append(Dir, "clang", "lib", "linux");
-  SmallString<128> P(Dir);
+  SmallString<128> P;
+  getClangLibraryPath(TC, Args, P);
   llvm::sys::path::append(P, LinuxLibName);
   Arguments.push_back(Args.MakeArgString(P));
 }
@@ -1228,11 +1252,21 @@ addLinkSanitizerLibArgsForDarwin(const ArgList &Args,
       /*AddRPath=*/ shared, TC);
 }
 
-static void
-addLinkSanitizerLibArgsForLinux(const ArgList &Args,
-                                 ArgStringList &Arguments,
-                                 StringRef Sanitizer, const ToolChain &TC) {
-  addLinkRuntimeLibForLinux(Args, Arguments,
+static void addLinkSanitizerLibArgsForWindows(const ArgList &Args,
+                                              ArgStringList &Arguments,
+                                              StringRef Sanitizer,
+                                              const ToolChain &TC) {
+  addLinkRuntimeLibForWindows(
+      Args, Arguments,
+      getSanitizerRuntimeLibNameForWindows(Sanitizer, TC.getTriple()), TC);
+}
+
+static void addLinkSanitizerLibArgsForLinux(const ArgList &Args,
+                                            ArgStringList &Arguments,
+                                            StringRef Sanitizer,
+                                            const ToolChain &TC) {
+  addLinkRuntimeLibForLinux(
+      Args, Arguments,
       getSanitizerRuntimeLibNameForLinux(Sanitizer, TC.getTriple()), TC);
 
   // Code taken from
@@ -1510,24 +1544,148 @@ toolchains::Darwin::constructInvocation(const LinkJobAction &job,
   return II;
 }
 
+ToolChain::InvocationInfo
+toolchains::Windows::constructInvocation(const LinkJobAction &job,
+                                         const JobContext &context) const {
+  assert(context.Output.getPrimaryOutputType() == file_types::TY_Image &&
+         "Invalid linker output type.");
+
+  ArgStringList Arguments;
+
+  switch (job.getKind()) {
+  case LinkKind::None:
+    llvm_unreachable("invalid link kind");
+  case LinkKind::Executable:
+    // Default case, nothing extra needed.
+    break;
+  case LinkKind::DynamicLibrary:
+    Arguments.push_back("-shared");
+    break;
+  }
+
+  // Select the linker to use.
+  std::string Linker;
+  if (const Arg *A = context.Args.getLastArg(options::OPT_use_ld)) {
+    Linker = A->getValue();
+  }
+  if (!Linker.empty())
+    Arguments.push_back(context.Args.MakeArgString("-fuse-ld=" + Linker));
+
+  // Configure the toolchain.
+  // By default, use the system clang++ to link.
+  const char *Clang = nullptr;
+  if (const Arg *A = context.Args.getLastArg(options::OPT_tools_directory)) {
+    StringRef toolchainPath(A->getValue());
+
+    // If there is a clang in the toolchain folder, use that instead.
+    if (auto toolchainClang =
+            llvm::sys::findProgramByName("clang++", {toolchainPath}))
+      Clang = context.Args.MakeArgString(toolchainClang.get());
+  }
+  if (Clang == nullptr) {
+    if (auto pathClang = llvm::sys::findProgramByName("clang++", None))
+      Clang = context.Args.MakeArgString(pathClang.get());
+  }
+  assert(Clang &&
+         "clang++ was not found in the toolchain directory or system path.");
+
+  std::string Target = getTriple().str();
+  if (!Target.empty()) {
+    Arguments.push_back("-target");
+    Arguments.push_back(context.Args.MakeArgString(Target));
+  }
+
+  SmallString<128> SharedRuntimeLibPath;
+  getRuntimeLibraryPath(SharedRuntimeLibPath, context.Args, *this,
+                        /*Shared=*/true);
+
+  // Link the standard library.
+  Arguments.push_back("-L");
+  if (context.Args.hasFlag(options::OPT_static_stdlib,
+                           options::OPT_no_static_stdlib, false)) {
+    SmallString<128> StaticRuntimeLibPath;
+    getRuntimeLibraryPath(StaticRuntimeLibPath, context.Args, *this,
+                          /*Shared=*/false);
+
+    // Since Windows has separate libraries per architecture, link against the
+    // architecture specific version of the static library.
+    Arguments.push_back(context.Args.MakeArgString(StaticRuntimeLibPath + "/" +
+                                                   getTriple().getArchName()));
+  } else {
+    Arguments.push_back(context.Args.MakeArgString(SharedRuntimeLibPath + "/" +
+                                                   getTriple().getArchName()));
+  }
+
+  SmallString<128> swiftrtPath = SharedRuntimeLibPath;
+  llvm::sys::path::append(swiftrtPath,
+                          swift::getMajorArchitectureName(getTriple()));
+  llvm::sys::path::append(swiftrtPath, "swiftrt.o");
+  Arguments.push_back(context.Args.MakeArgString(swiftrtPath));
+
+  addPrimaryInputsOfType(Arguments, context.Inputs, context.Args,
+                         file_types::TY_Object);
+  addInputsOfType(Arguments, context.InputActions, file_types::TY_Object);
+
+  for (const Arg *arg :
+       context.Args.filtered(options::OPT_F, options::OPT_Fsystem)) {
+    if (arg->getOption().matches(options::OPT_Fsystem))
+      Arguments.push_back("-iframework");
+    else
+      Arguments.push_back(context.Args.MakeArgString(arg->getSpelling()));
+    Arguments.push_back(arg->getValue());
+  }
+
+  if (!context.OI.SDKPath.empty()) {
+    Arguments.push_back("-I");
+    Arguments.push_back(context.Args.MakeArgString(context.OI.SDKPath));
+  }
+
+  if (job.getKind() == LinkKind::Executable) {
+    if (context.OI.SelectedSanitizers & SanitizerKind::Address)
+      addLinkSanitizerLibArgsForWindows(context.Args, Arguments, "asan", *this);
+  }
+
+  if (context.Args.hasArg(options::OPT_profile_generate)) {
+    SmallString<128> LibProfile(SharedRuntimeLibPath);
+    llvm::sys::path::remove_filename(LibProfile); // remove platform name
+    llvm::sys::path::append(LibProfile, "clang", "lib");
+
+    llvm::sys::path::append(LibProfile, getTriple().getOSName(),
+                            Twine("clang_rt.profile-") +
+                                getTriple().getArchName() + ".lib");
+    Arguments.push_back(context.Args.MakeArgString(LibProfile));
+    Arguments.push_back(context.Args.MakeArgString(
+        Twine("-u", llvm::getInstrProfRuntimeHookVarName())));
+  }
+
+  context.Args.AddAllArgs(Arguments, options::OPT_Xlinker);
+  context.Args.AddAllArgs(Arguments, options::OPT_linker_option_Group);
+
+  // This should be the last option, for convenience in checking output.
+  Arguments.push_back("-o");
+  Arguments.push_back(
+      context.Args.MakeArgString(context.Output.getPrimaryOutputFilename()));
+
+  return {Clang, Arguments};
+}
+
 ToolChain::InvocationInfo
 toolchains::GenericUnix::constructInvocation(const InterpretJobAction &job,
                                              const JobContext &context) const {
   InvocationInfo II = ToolChain::constructInvocation(job, context);
 
   SmallString<128> runtimeLibraryPath;
-  getRuntimeLibraryPath(runtimeLibraryPath, context.Args, *this, /*Shared=*/ true);
+  getRuntimeLibraryPath(runtimeLibraryPath, context.Args, *this,
+                        /*Shared=*/true);
 
   addPathEnvironmentVariableIfNeeded(II.ExtraEnvironment, "LD_LIBRARY_PATH",
                                      ":", options::OPT_L, context.Args,
                                      runtimeLibraryPath);
   return II;
 }
 
-
-ToolChain::InvocationInfo
-toolchains::GenericUnix::constructInvocation(const AutolinkExtractJobAction &job,
-                                             const JobContext &context) const {
+ToolChain::InvocationInfo toolchains::GenericUnix::constructInvocation(
+    const AutolinkExtractJobAction &job, const JobContext &context) const {
   assert(context.Output.getPrimaryOutputType() == file_types::TY_AutolinkFile);
 
   ArgStringList Arguments;
@@ -1536,14 +1694,14 @@ toolchains::GenericUnix::constructInvocation(const AutolinkExtractJobAction &job
   addInputsOfType(Arguments, context.InputActions, file_types::TY_Object);
 
   Arguments.push_back("-o");
-  Arguments.push_back(context.Args.MakeArgString(
-      context.Output.getPrimaryOutputFilename()));
+  Arguments.push_back(
+      context.Args.MakeArgString(context.Output.getPrimaryOutputFilename()));
 
   return {"swift-autolink-extract", Arguments};
 }
 
 std::string toolchains::GenericUnix::getDefaultLinker() const {
-  switch(getTriple().getArch()) {
+  switch (getTriple().getArch()) {
   case llvm::Triple::arm:
   case llvm::Triple::armeb:
   case llvm::Triple::thumb:

diff --git a/lib/Driver/ToolChains.h b/lib/Driver/ToolChains.h
@@ -39,6 +39,20 @@ class LLVM_LIBRARY_VISIBILITY Darwin : public ToolChain {
       const override;
 };
 
+class LLVM_LIBRARY_VISIBILITY Windows : public ToolChain {
+protected:
+  InvocationInfo constructInvocation(const LinkJobAction &job,
+                                     const JobContext &context) const override;
+
+public:
+  Windows(const Driver &D, const llvm::Triple &Triple) : ToolChain(D, Triple) {}
+  ~Windows() = default;
+  bool sanitizerRuntimeLibExists(const llvm::opt::ArgList &args,
+                                 StringRef sanitizerLibName,
+                                 bool shared)
+      const override;
+};
+
 class LLVM_LIBRARY_VISIBILITY GenericUnix : public ToolChain {
 protected:
   InvocationInfo constructInvocation(const InterpretJobAction &job,

diff --git a/lib/Option/SanitizerOptions.cpp b/lib/Option/SanitizerOptions.cpp
@@ -160,8 +160,8 @@ OptionSet<SanitizerKind> swift::parseSanitizerArgValues(
     }
   }
 
-  // Sanitizers are only supported on Linux or Darwin.
-  if (!(Triple.isOSDarwin() || Triple.isOSLinux())) {
+  // Check that we're one of the known supported targets for sanitizers.
+  if (!(Triple.isOSDarwin() || Triple.isOSLinux() || Triple.isOSWindows())) {
     SmallString<128> b;
     Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target,
       (A->getOption().getPrefixedName() +

diff --git a/test/Driver/Inputs/fake-resource-dir/lib/swift/clang/lib/windows/clang_rt.asan-x86_64.lib b/test/Driver/Inputs/fake-resource-dir/lib/swift/clang/lib/windows/clang_rt.asan-x86_64.lib
diff --git a/test/Driver/linker.swift b/test/Driver/linker.swift
@@ -33,6 +33,9 @@
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-cygnus -Ffoo -Fsystem car -F cdr -framework bar -Lbaz -lboo -Xlinker -undefined %s 2>&1 > %t.cygwin.txt
 // RUN: %FileCheck -check-prefix CYGWIN-x86_64 %s < %t.cygwin.txt
 
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-msvc -Ffoo -Fsystem car -F cdr -framework bar -Lbaz -lboo -Xlinker -undefined %s 2>&1 > %t.windows.txt
+// RUN: %FileCheck -check-prefix WINDOWS-x86_64 %s < %t.windows.txt
+
 // RUN: %swiftc_driver -driver-print-jobs -emit-library -target x86_64-unknown-linux-gnu %s -Lbar -o dynlib.out 2>&1 > %t.linux.dynlib.txt
 // RUN: %FileCheck -check-prefix LINUX_DYNLIB-x86_64 %s < %t.linux.dynlib.txt
 
@@ -61,6 +64,7 @@
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-apple-macosx10.9 -emit-library %s -module-name LINKER | %FileCheck -check-prefix INFERRED_NAME_DARWIN %s
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-linux-gnu -emit-library %s -module-name LINKER | %FileCheck -check-prefix INFERRED_NAME_LINUX %s
 // RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-cygnus -emit-library %s -module-name LINKER | %FileCheck -check-prefix INFERRED_NAME_WINDOWS %s
+// RUN: %swiftc_driver -driver-print-jobs -target x86_64-unknown-windows-msvc -emit-library %s -module-name LINKER | %FileCheck -check-prefix INFERRED_NAME_WINDOWS %s
 
 // Here we specify an output file name using '-o'. For ease of writing these
 // tests, we happen to specify the same file name as is inferred in the
@@ -240,6 +244,20 @@
 // CYGWIN-x86_64-DAG: -Xlinker -undefined
 // CYGWIN-x86_64: -o linker
 
+// WINDOWS-x86_64: swift
+// WINDOWS-x86_64: -o [[OBJECTFILE:.*]]
+
+// WINDOWS-x86_64: clang++{{"? }}
+// WINDOWS-x86_64-DAG: [[OBJECTFILE]]
+// WINDOWS-x86_64-DAG: -L [[STDLIB_PATH:[^ ]+/lib/swift/windows/x86_64]]
+// WINDOWS-x86_64-DAG: -F foo -iframework car -F cdr
+// WINDOWS-x86_64-DAG: -framework bar
+// WINDOWS-x86_64-DAG: -L baz
+// WINDOWS-x86_64-DAG: -lboo
+// WINDOWS-x86_64-DAG: -Xlinker -undefined
+// WINDOWS-x86_64: -o linker
+
+
 // COMPLEX: bin/ld{{"? }}
 // COMPLEX-DAG: -dylib
 // COMPLEX-DAG: -syslibroot {{.*}}/Inputs/clang-importer-sdk

diff --git a/test/Driver/profiling.swift b/test/Driver/profiling.swift
@@ -18,6 +18,7 @@
 // RUN: %swiftc_driver -driver-print-jobs -profile-generate -target armv7k-apple-watchos2.0 -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ %s | %FileCheck -check-prefix=CHECK -check-prefix=watchOS %s
 
 // RUN: %swiftc_driver -driver-print-jobs -profile-generate -target x86_64-unknown-linux-gnu %s | %FileCheck -check-prefix=CHECK -check-prefix=LINUX %s
+// RUN: %swiftc_driver -driver-print-jobs -profile-generate -target x86_64-unknown-windows-msvc %s | %FileCheck -check-prefix=CHECK -check-prefix=WINDOWS %s
 
 // CHECK: swift
 // CHECK: -profile-generate
@@ -47,6 +48,10 @@
 // LINUX: lib/swift/clang/lib/linux/libclang_rt.profile-x86_64.a
 // LINUX: -u__llvm_profile_runtime
 
+// WINDOWS: clang++{{"? }}
+// WINDOWS: lib/swift/clang/lib/windows/clang_rt.profile-x86_64.lib
+// WINDOWS: -u__llvm_profile_runtime
+
 // RUN: not %swiftc_driver -driver-print-jobs -profile-generate -profile-use=/dev/null %s 2>&1 | %FileCheck -check-prefix=MIX_GEN_USE %s
 // MIX_GEN_USE: conflicting options '-profile-generate' and '-profile-use'
 

diff --git a/test/Driver/sanitizers.swift b/test/Driver/sanitizers.swift
@@ -7,6 +7,7 @@
 // RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=address -target i386-apple-watchos2.0 %s   | %FileCheck -check-prefix=ASAN -check-prefix=ASAN_watchOS_SIM %s
 // RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=address -target armv7k-apple-watchos2.0 %s | %FileCheck -check-prefix=ASAN -check-prefix=ASAN_watchOS %s
 // RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=address -target x86_64-unknown-linux-gnu %s 2>&1 | %FileCheck -check-prefix=ASAN_LINUX %s
+// RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=address -target x86_64-unknown-windows-msvc %s 2>&1 | %FileCheck -check-prefix=ASAN_WINDOWS %s
 
 // RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target x86_64-apple-macosx10.9 %s | %FileCheck -check-prefix=TSAN -check-prefix=TSAN_OSX %s
 // RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target x86-apple-macosx10.9 %s 2>&1 | %FileCheck -check-prefix=TSAN_OSX_32 %s
@@ -16,6 +17,7 @@
 // RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target arm64-apple-tvos9.0 %s 2>&1 | %FileCheck -check-prefix=TSAN_tvOS %s
 // RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target i386-apple-watchos2.0 %s 2>&1 | %FileCheck -check-prefix=TSAN_watchOS_SIM %s
 // RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target armv7k-apple-watchos2.0 %s 2>&1  | %FileCheck -check-prefix=TSAN_watchOS %s
+// RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target x86_64-unknown-windows-msvc %s 2>&1 | %FileCheck -check-prefix=TSAN_WINDOWS %s
 // RUN: %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=thread -target x86_64-unknown-linux-gnu %s 2>&1 | %FileCheck -check-prefix=TSAN_LINUX %s
 
 // RUN: not %swiftc_driver -resource-dir %S/Inputs/fake-resource-dir/lib/swift/ -driver-print-jobs -sanitize=address,unknown %s 2>&1 | %FileCheck -check-prefix=BADARG %s
@@ -41,6 +43,7 @@
 // ASAN_watchOS_SIM: lib/swift/clang/lib/darwin/libclang_rt.asan_watchossim_dynamic.dylib
 // ASAN_watchOS: lib/swift/clang/lib/darwin/libclang_rt.asan_watchos_dynamic.dylib
 // ASAN_LINUX: lib/swift/clang/lib/linux/libclang_rt.asan-x86_64.a
+// ASAN_WINDOWS: lib/swift/clang/lib/windows/clang_rt.asan-x86_64.lib
 
 // ASAN: -rpath @executable_path
 
@@ -57,6 +60,7 @@
 // TSAN_watchOS: unsupported option '-sanitize=thread' for target 'armv7k-apple-watchos2.0'
 // FUZZER_NONEXISTENT: unsupported option '-sanitize=fuzzer' for target 'x86_64-apple-macosx10.9'
 // TSAN_LINUX: lib/swift/clang/lib/linux/libclang_rt.tsan-x86_64.a
+// TSAN_WINDOWS: unsupported option '-sanitize=thread' for target 'x86_64-unknown-windows-msvc'
 
 // TSAN: -rpath @executable_path