Make lld-link work in a non-MSVC shell

[pkasting]

Summary

Makes lld-link work in a non-MSVC shell by autodetecting MSVC toolchain. Also adds support for /winsysroot and a few other switches.

All this is done by refactoring to share code with clang-cl's existing support for the same.

[pkasting]

Rebase

[thakis]

Very very cool.

This needs a test. Maybe you just forgot to git add it?

It'd be nice if the knowledge what the sysroot layout looks like (a Windows\ Kits/10/... dir, a VC/Tools/MSVC/*/ dir, optionally a DIA SDK dir) wasn't duplicated between here and clang. Could we pull that out into some common code in llvm/lib/Support and call that in both places?

(@ychen fyi wrt D117852)

lld/COFF/Driver.cpp

273

Include seems like the wrong directory to look in in the linker (…i think?)

670

there's a bunch of these unrelated sys:: removals sprinkled through the patch. send them in a separate patch, they're unrelated.

703

We shouldn't look at %LIB% here when /winsysroot: is passed.

[pkasting]

Adds autodetection and full support for other clang-cl switches, but doesn't work: config->machine is not set this early, so it's always UNKNOWN.

[pkasting]

Functional, but not yet refactored to share code with clang-cl.

[pkasting]

Refactored to share code with clang-cl. Still no tests.

[thakis]

This looks super nice.

Things that can still improve:

1. This now does way more than just /winsysroot:. It also makes it so that lld-link works in a non-msvc shell by looking up libpaths in either registry or via setup api.
2. Some of the new lld-link code still looks (from a distance, might be wrong) like it could be shared more
3. Still needs tests.

@mstorsjo, fyi.

clang/docs/tools/clang-formatted-files.txt

1 ↗

(On Diff #403679)

TIL about the existence of clang/docs/tools/clang-formatted-files.txt :)

clang/lib/Driver/ToolChains/MSVC.cpp

465 ↗

(On Diff #403679)

Should these be member variables? Looks like we need them in a bunch of places.

lld/COFF/Driver.cpp

230

this function looks kind of similar to one in clang. Maybe the arch paths could be passed in and then this could be shared (?)

703

Oh I see, this is now no longer called if winsysroot is passed.

722

Do you think it's possible to get this logic here (this path if ucrt else this other path, etc) shared between the two places? Maybe a getLibPaths() function that's passed arch etc?

lld/COFF/SymbolTable.cpp

59 ↗

(On Diff #403679)

I suppose this is good enough :)

If we wanted to get fancy, we could put in code to explicitly detect the case of a .lib file not being found, and addWinSysRootLibSearchPaths() not having been called yet (due to the machine type not yet being know), and then diag something like ".lib not found. you passed /winsysroot:, try passing /machine: too". But I don't think this will ever happen in practice, so I think it's not worth worrying about.

utils/bazel/llvm-project-overlay/clang/BUILD.bazel

1314 ↗

(On Diff #403679)

(fwiw you don't have to update BUILD.bazel files)

[pkasting]

In D118070#3278123, @thakis wrote:

Things that can still improve:

1. This now does way more than just /winsysroot:. It also makes it so that lld-link works in a non-msvc shell by looking up libpaths in either registry or via setup api.

Updated description.

2. Some of the new lld-link code still looks (from a distance, might be wrong) like it could be shared more

Did what I think I could, see details in comments.

3. Still needs tests.

Added a few basic tests, please review.

lld/COFF/Driver.cpp

172

Found a way to share these.

273

I think this is OK. It's not obvious to me that we can change this to a .lib check safely, and I think clang and lld should use the same logic to detect ucrt.

703

Yep, added a test for this too.

722

The big problem is that in lld this logic is split between the two phases (pre-run() and post-run()) and can't easily be moved entirely into the post-run() phase. So we'd only be able to share the logic that is here in the pre-run phase (the code that doesn't need the arch), which would make the clang code quite cumbersome.

I think it's not worth trying.

766

Found a way to share this.

lld/COFF/SymbolTable.cpp

59 ↗

(On Diff #403679)

I think this can only happen for defaultlibs? ...and those get processed after we set the machine type now, so there can't be a problem here. Or at least, I couldn't find a way to trigger one in practice -- all my attempts led the linker to instead complain "No input files." So I'm gonna call this N/A, but if you think of a command line to trigger it so I can test it, let me know.

utils/bazel/llvm-project-overlay/clang/BUILD.bazel

1314 ↗

(On Diff #403679)

Shrug, it's not hard to do so. And already done now, so...

[ychen]

Thanks for doing this! Update the release note?

[MaskRay]

I know that you want a place to be accessed by both clang driver and lld-link but I am a bit nervous about the clang-driver style MSVC library sitting inside llvm/lib/Support/.
Is there a better place? @compnerd @aganea

[aganea]

In D118070#3289227, @MaskRay wrote:

I know that you want a place to be accessed by both clang driver and lld-link but I am a bit nervous about the clang-driver style MSVC library sitting inside llvm/lib/Support/.
Is there a better place? @compnerd @aganea

Does it make sense to add a new platform library? LLVMPlatformWindows? LLVMWindows? LLVMWindowsTools? LLVMWindowsABI?

Makes lld-link work in a non-MSVC shell by autodetecting MSVC toolchain. Also adds support for /winsysroot and a few other switches.

@pkasting Note, this patch makes the outcome non-deterministic when the auto-detection kicks in. We are stamping the command-line the .PDB file, see https://github.com/llvm/llvm-project/blob/main/lld/COFF/PDB.cpp#L1402 - and some live-code-patching tools rely on that to reproduce the link. It'd be nice if the detected paths are queued to config->argv, to ensure that we can emit a self-standing LLD cmd-line, a bit like what clang -cc1 does.

lld/COFF/Driver.h

118

You could also use saver().save(...) below and keep this member intact. That would save some memory allocations.

[MaskRay]

In D118070#3290194, @aganea wrote:

In D118070#3289227, @MaskRay wrote:

I know that you want a place to be accessed by both clang driver and lld-link but I am a bit nervous about the clang-driver style MSVC library sitting inside llvm/lib/Support/.
Is there a better place? @compnerd @aganea

Does it make sense to add a new platform library? LLVMPlatformWindows? LLVMWindows? LLVMWindowsTools? LLVMWindowsABI?

There is a precedent: llvm/lib/WindowsManifest. So having a library in llvm/lib/ seems fine. I do not know whether it makes sense to combine the Windows driver library with WindowsManifest.

[thakis]

@pkasting Note, this patch makes the outcome non-deterministic when the auto-detection kicks in. We are stamping the command-line the .PDB file, see https://github.com/llvm/llvm-project/blob/main/lld/COFF/PDB.cpp#L1402 - and some live-code-patching tools rely on that to reproduce the link. It'd be nice if the detected paths are queued to config->argv, to ensure that we can emit a self-standing LLD cmd-line, a bit like what clang -cc1 does.

You mean "non-deterministic" in "cmd.exe / local-computer dependent", yes? If so: There are enough flags that you can pass in to make the output deterministic if this is something you care about. (We care about determinism a lot over in chromium land!) I think the setup matches what we have in clang, right?

[pkasting]

In D118070#3289222, @ychen wrote:

Thanks for doing this! Update the release note?

Done.

[pkasting]

In D118070#3297956, @thakis wrote:

I think the setup matches what we have in clang, right?

Yes, I think so.

[pkasting]

This fixes a failing test.

[thakis]

I think this looks great.

maskray, I kind of see where you're coming from. And I'm _very_ sympathetic to keeping Support small(er). On the other hand, this is a single file that doesn't require any additional dependencies on libs (…I think), so a dedicated library feels a bit overkill to me, maybe. (Are there any "when not to put your stuff in Support" guidelines anywhere?)

lld/COFF/Driver.cpp

187

Maybe this function could be in the shared part too? Looks like basically exactly this code is in both places.

lld/docs/ReleaseNotes.rst

38 ↗

(On Diff #406526)

Maybe mention /winsysroot: here too

[pkasting]

Review comments.

[pkasting]

MaskRay: Friendly ping.

[MaskRay]

In D118070#3308304, @pkasting wrote:

MaskRay: Friendly ping.

I think I still feel that having this in LLVMSupport is strange, but am happy if the two other folks I added are happy...

[thakis]

I went ahead and landed this for now. It's easy to move the 3 new files to their own library later on if we decide it's something we want to do.

Thanks for the patch!

[aprantl]

Unfortunately this seems to break the modular build. Would you mind taking a look? I'm going to revert the patch to get the bots going again.

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/41306/console

llvm/include/llvm/Support/MSVCPaths.h

15 ↗

(On Diff #407955)

This introduces a cyclic dependency that breaks the -DLLVM_ENABLE_MODULES=1 build.

/Volumes/Data/llvm-project/llvm/include/llvm/Option/Arg.h:17:10: fatal error: cyclic dependency in module 'LLVM_Utils': LLVM_Utils -> LLVM_Option -> LLVM_Utils
#include "llvm/ADT/SmallVector.h"
         ^
While building module 'LLVM_Utils' imported from /Volumes/Data/llvm-project/llvm/lib/Support/ARMBuildAttrs.cpp:9:
In file included from <module-includes>:195:
/Volumes/Data/llvm-project/llvm/include/llvm/Support/MSVCPaths.h:14:10: fatal error: could not build module 'LLVM_Option'
#include "llvm/Option/ArgList.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
/Volumes/Data/llvm-project/llvm/lib/Support/ARMBuildAttrs.cpp:9:10: fatal error: could not build module 'LLVM_Utils'
#include "llvm/Support/ARMBuildAttributes.h"
 ~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3 errors generated.

[thakis]

Thanks for the revert!

Is there any documentation for that LLVM_ENABLE_MODULES build config anywhere?

[thakis]

llvm/include/llvm/Support/MSVCPaths.h

15 ↗

(On Diff #407955)

Ah yeah, support can't depend on Option. Maybe the easiest fix is to just move this to its own library like maskray suggested. Then this isn't a problem.

[thakis]

Relanded in 73e585e44d68cf77e2e3274e98c9615156a7d909, with the new files in a new WindowsDriver library.

[dyung]

I'm not exactly sure why, but this change seems to be causing the Driver/cl-options.c test to fail on the PS4 Windows bot:

https://lab.llvm.org/staging/#/builders/204/builds/1343

It was also failing previously after the original commit until it was reverted at which point it started to pass again.

[thakis]

It fails on this:

// Validate that the default triple is used when run an empty tools dir is specified
// RUN: %clang_cl -vctoolsdir "" -### -- %s 2>&1 | FileCheck %s --check-prefix VCTOOLSDIR
// VCTOOLSDIR: "-triple" "{{[a-zA-Z0-9_-]*}}-pc-windows-msvc19.20.0"

With this:

C:\buildbot-root\llvm-clang-x86_64-sie-win\llvm-project\clang\test\Driver\cl-options.c:761:16: error: VCTOOLSDIR: expected string not found in input
// VCTOOLSDIR: "-triple" "{{[a-zA-Z0-9_-]*}}-pc-windows-msvc19.20.0"
               ^
<stdin>:1:1: note: scanning from here
clang version 15.0.0 (https://github.com/llvm/llvm-project.git 0574b5fc657451c9d13d3f6d8fe14ea15c23a681)
^
<stdin>:5:68: note: possible intended match here
 "c:\\buildbot-root\\llvm-clang-x86_64-sie-win\\build\\bin\\clang.exe" "-cc1" "-triple" "x86_64-pc-windows-msvc19.29.30137" ...

That test was added in D85998.

I think this is a true regression. findVCToolChainViaCommandLine() used to return true on present-but-empty strings, but llvm::findVCToolChainViaCommandLine() uses the empty string as "not set".

The fix is probably to make llvm::findVCToolChainViaCommandLine() take Optional<StringRef>s instead, and use the Optional value instead of string emptiness.

It's late over here, so I won't get to that myself today. Feel free to revert for now.

[dyung]

I've reverted this and the follow-up change to fix the build in 437d4e01fe4c057509dff30efd560049ad07bc99.

[thakis]

Thanks for the revert!

FWIW, also failed on https://ci.chromium.org/ui/p/chromium/builders/try/win_upload_clang/2069/overview / https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket/8822456541383185105/+/u/package_clang/stdout?format=raw . So maybe it's not a super exotic failure.

[thakis]

(reopening for fixing things + relanding)

[thakis]

(also marking as "request changes" for the Optional<StringRef> change we need)

[pkasting]

Fix test failure.

[thakis]

Thanks! Relanding.

[thakis]

The bot that broke last time stayed green on the reland: https://lab.llvm.org/staging/#/builders/204/builds/1591 :)

lld/COFF/Driver.h

private:
   Optional<StringRef> findFile(StringRef filename);
   Optional<StringRef> findLib(StringRef filename);
   StringRef doFindFile(StringRef filename);
   StringRef doFindLib(StringRef filename);
   StringRef doFindLibMinGW(StringRef filename);
 
   bool findUnderscoreMangle(StringRef sym);
 
+  // Adds appropriate search paths from `sysroot`.
+  void addWinSysRootLibSearchPaths(StringRef sysroot);
+
   // Parses LIB environment which contains a list of search paths.
   void addLibSearchPaths();
 
   // Library search path. The first element is always "" (current directory).
   std::vector<StringRef> searchPaths;
 
   // Convert resource files and potentially merge input resource object
   // trees into one resource tree.
   void convertResources();
 
   void maybeExportMinGWSymbols(const llvm::opt::InputArgList &args);
 
   // We don't want to add the same file more than once.

lld/COFF/Driver.cpp

 #include "llvm/Object/COFFModuleDefinition.h"
 #include "llvm/Object/WindowsMachineFlag.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TarWriter.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"

 // ".exe", ".dll" or ".sys".
 static std::string getOutputPath(StringRef path) {
   StringRef ext = ".exe";
   if (config->dll)
     ext = ".dll";
   else if (config->driver)
     ext = ".sys";
 
-  return (sys::path::stem(path) + ext).str();
+  return (path::stem(path) + ext).str();
 }
 
 // Returns true if S matches /crtend.?\.o$/.
 static bool isCrtend(StringRef s) {
   if (!s.endswith(".o"))
     return false;
   s = s.drop_back(2);
   if (s.endswith("crtend"))

 // Symbol names are mangled by prepending "_" on x86.
 static StringRef mangle(StringRef sym) {
   assert(config->machine != IMAGE_FILE_MACHINE_UNKNOWN);
   if (config->machine == I386)
     return saver.save("_" + sym);
   return sym;
 }
 
+static std::string getHighestNumericTupleInDirectory(StringRef Directory) {
+  std::string Highest;
+  VersionTuple HighestTuple;
+
+  std::error_code EC;
+  for (fs::directory_iterator DirIt(Directory, EC), DirEnd;
+       !EC && DirIt != DirEnd; DirIt.increment(EC)) {
+
+    if (!fs::is_directory(DirIt->path()))
+      continue;
+    StringRef CandidateName = path::filename(DirIt->path());
+    VersionTuple Tuple;
+    if (Tuple.tryParse(CandidateName)) // tryParse() returns true on error.
+      continue;
+    if (Tuple > HighestTuple) {
+      HighestTuple = Tuple;
+      Highest = CandidateName.str();
+    }
+  }
+
+  return Highest;
+}
+
+static const char *getWindowsSDKArch() {
+  switch (config->machine) {
+  case I386:
+    return "x86";
+  case AMD64:
+    return "x64";
+  case ARMNT:
+    return "arm";
+  case ARM64:
+    return "arm64";
+  default:
+    return "";
+  }
+}
+
+static const char *getLegacyVCArch() {
+  switch (config->machine) {
+  case I386:
+    // x86 is default in legacy VC toolchains.
+    // e.g. x86 libs are directly in /lib as opposed to /lib/x86.
+    return "";
+  case AMD64:
+    return "amd64";
+  case ARMNT:
+    return "arm";
+  case ARM64:
+    return "arm64";
+  default:
+    return "";
+  }
+}
+
+enum class SubDirectoryType {
+  Bin,
+  Include,
+  Lib,
+};
+
+std::string getSubDirectoryPath(SubDirectoryType Type,
+                                StringRef VCToolChainPath,
+                                StringRef SubdirParent = "") {
+  const char *SubdirName = getWindowsSDKArch();
+
+  SmallString<256> Path(VCToolChainPath);
+  if (!SubdirParent.empty())
+    path::append(Path, SubdirParent);
+
+  switch (Type) {
+  case SubDirectoryType::Bin: {
+    const bool HostIsX64 = Triple(getProcessTriple()).isArch64Bit();
+    const char *const HostName = HostIsX64 ? "Hostx64" : "Hostx86";
+    path::append(Path, "bin", HostName, SubdirName);
+    break;
+  }
+  case SubDirectoryType::Include:
+    path::append(Path, "include");
+    break;
+  case SubDirectoryType::Lib:
+    path::append(Path, "lib", SubdirName);
+    break;
+  }
+  return std::string(Path.str());
+}
+
+// Check if the Include path of a specified version of Visual Studio contains
+// specific header files. If not, they are probably shipped with Universal CRT.
+static bool useUniversalCRT(StringRef VCToolChainPath) {
+  SmallString<128> TestPath(
+      getSubDirectoryPath(SubDirectoryType::Include, VCToolChainPath));
+  path::append(TestPath, "stdlib.h");
+  return !fs::exists(TestPath);
+}
+
+static void getWindowsSDKDirViaCommandLine(StringRef sysroot, std::string &Path,
+                                           std::string &Version) {
+  SmallString<128> SDKPath(sysroot);
+  path::append(SDKPath, "Windows Kits");
+  path::append(SDKPath, getHighestNumericTupleInDirectory(SDKPath));
+  Path = std::string(SDKPath.str());
+
+  path::append(SDKPath, "Include");
+  Version = getHighestNumericTupleInDirectory(SDKPath);
+}
+
+static bool getUniversalCRTLibraryPath(StringRef sysroot, std::string &Path) {
+  Path.clear();
+
+  StringRef ArchName = getWindowsSDKArch();
+  if (ArchName.empty())
+    return false;
+
+  std::string UCRTVersion;
+  getWindowsSDKDirViaCommandLine(sysroot, Path, UCRTVersion);
+  llvm::SmallString<128> LibPath(Path);
+  llvm::sys::path::append(LibPath, "Lib", UCRTVersion, "ucrt", ArchName);
+  Path = std::string(LibPath.str());
+  return true;
+}
+
+static bool getWindowsSDKLibraryPath(StringRef sysroot, std::string &Path) {
+  std::string sdkPath;
+  std::string windowsSDKLibVersion;
+
+  Path.clear();
+  getWindowsSDKDirViaCommandLine(sysroot, sdkPath, windowsSDKLibVersion);
+
+  SmallString<128> libPath(sdkPath);
+  path::append(libPath, "Lib");
+  if (!windowsSDKLibVersion.empty()) {
+    path::append(libPath, windowsSDKLibVersion, "um", getWindowsSDKArch());
+  } else {
+    switch (config->machine) {
+    // In Windows SDK 7.x, x86 libraries are directly in the Lib folder.
+    case I386:
+      break;
+    case AMD64:
+      path::append(libPath, "x64");
+      break;
+    case ARMNT:
+      // It is not necessary to link against Windows SDK 7.x when targeting ARM.
+      return false;
+    default:
+      return false;
+    }
+  }
+
+  Path = std::string(libPath.str());
+  return true;
+}
+
 bool LinkerDriver::findUnderscoreMangle(StringRef sym) {
   Symbol *s = ctx.symtab.findMangle(mangle(sym));
   return s && !isa<Undefined>(s);
 }
 
 MemoryBufferRef LinkerDriver::takeBuffer(std::unique_ptr<MemoryBuffer> mb) {
   MemoryBufferRef mbref = *mb;
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take ownership

 // care of that. Note that the returned path is not guaranteed to exist.
 StringRef LinkerDriver::doFindFile(StringRef filename) {
   bool hasPathSep = (filename.find_first_of("/\\") != StringRef::npos);
   if (hasPathSep)
     return filename;
   bool hasExt = filename.contains('.');
   for (StringRef dir : searchPaths) {
     SmallString<128> path = dir;
-    sys::path::append(path, filename);
-    if (sys::fs::exists(path.str()))
+    path::append(path, filename);
+    if (fs::exists(path.str()))
       return saver.save(path.str());
     if (!hasExt) {
       path.append(".obj");
-      if (sys::fs::exists(path.str()))
+      if (fs::exists(path.str()))
         return saver.save(path.str());
     }
   }
   return filename;
 }
 
-static Optional<sys::fs::UniqueID> getUniqueID(StringRef path) {
-  sys::fs::UniqueID ret;
-  if (sys::fs::getUniqueID(path, ret))
+static Optional<fs::UniqueID> getUniqueID(StringRef path) {
+  fs::UniqueID ret;
+  if (fs::getUniqueID(path, ret))
     return None;
   return ret;
 }
 
 // Resolves a file path. This never returns the same path
 // (in that case, it returns None).
 Optional<StringRef> LinkerDriver::findFile(StringRef filename) {
   StringRef path = doFindFile(filename);
 
-  if (Optional<sys::fs::UniqueID> id = getUniqueID(path)) {
+  if (Optional<fs::UniqueID> id = getUniqueID(path)) {
     bool seen = !visitedFiles.insert(*id).second;
     if (seen)
       return None;
   }
 
   if (path.endswith_insensitive(".lib"))
-    visitedLibs.insert(std::string(sys::path::filename(path)));
+    visitedLibs.insert(std::string(path::filename(path)));
   return path;
 }
 
 // MinGW specific. If an embedded directive specified to link to
 // foo.lib, but it isn't found, try libfoo.a instead.
 StringRef LinkerDriver::doFindLibMinGW(StringRef filename) {
   if (filename.contains('/') || filename.contains('\\'))
     return filename;
 
   SmallString<128> s = filename;
-  sys::path::replace_extension(s, ".a");
+  path::replace_extension(s, ".a");
   StringRef libName = saver.save("lib" + s.str());
   return doFindFile(libName);
 }
 
 // Find library file from search path.
 StringRef LinkerDriver::doFindLib(StringRef filename) {
   // Add ".lib" to Filename if that has no file extension.
   bool hasExt = filename.contains('.');
if (config->noDefaultLibAll)
     return None;
   if (!visitedLibs.insert(filename.lower()).second)
     return None;
 
   StringRef path = doFindLib(filename);
   if (config->noDefaultLibs.count(path.lower()))
     return None;
 
-  if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
+  if (Optional<fs::UniqueID> id = getUniqueID(path))
     if (!visitedFiles.insert(*id).second)
       return None;
   return path;
 }
 
+void LinkerDriver::addWinSysRootLibSearchPaths(StringRef sysroot) {
+  SmallString<128> ToolsPath(sysroot);
+  path::append(ToolsPath, "VC", "Tools", "MSVC");
+  path::append(ToolsPath, getHighestNumericTupleInDirectory(ToolsPath));
+
+  SmallString<128> DIAPath(sysroot);
+  // The DIA SDK always uses the legacy vc arch, even in new MSVC versions.
+  path::append(DIAPath, "DIA SDK", "lib", getLegacyVCArch());
+  searchPaths.push_back(DIAPath);
+
+  searchPaths.push_back(getSubDirectoryPath(SubDirectoryType::Lib, ToolsPath));
+  searchPaths.push_back(
+      getSubDirectoryPath(SubDirectoryType::Lib, ToolsPath, "atlmfc"));
+
+  if (useUniversalCRT(ToolsPath)) {
+    std::string UniversalCRTLibPath;
+    if (getUniversalCRTLibraryPath(sysroot, UniversalCRTLibPath))
+      searchPaths.push_back(UniversalCRTLibPath);
+  }
+  std::string WindowsSdkLibPath;
+  if (getWindowsSDKLibraryPath(sysroot, WindowsSdkLibPath))
+    searchPaths.push_back(WindowsSdkLibPath);
+}
+
 // Parses LIB environment which contains a list of search paths.
 void LinkerDriver::addLibSearchPaths() {
   Optional<std::string> envOpt = Process::GetEnv("LIB");
   if (!envOpt.hasValue())
     return;
   StringRef env = saver.save(*envOpt);
   while (!env.empty()) {
     StringRef path;
     std::tie(path, env) = env.split(';');
     searchPaths.push_back(path);
   }
 }
 
 Symbol *LinkerDriver::addUndefined(StringRef name) {
   Symbol *b = ctx.symtab.addUndefined(name);
   if (!b->isGCRoot) {
     b->isGCRoot = true;
     config->gcroot.push_back(b);
   }
   return b;
 }
 
 StringRef LinkerDriver::mangleMaybe(Symbol *s) {
   // If the plain symbol name has already been resolved, do nothing.
   Undefined *unmangled = dyn_cast<Undefined>(s);
   if (!unmangled)
     return "";
 
   // Otherwise, see if a similar, mangled symbol exists in the symbol table.
   Symbol *mangled = ctx.symtab.findMangle(unmangled->getName());
if (findUnderscoreMangle("wWinMain")) {
         return mangle("wWinMainCRTStartup");
       warn("found both wWinMain and WinMain; using latter");
     }
     return mangle("WinMainCRTStartup");
   }
   if (findUnderscoreMangle("wmain")) {
     if (!findUnderscoreMangle("main"))
       return mangle("wmainCRTStartup");
     warn("found both wmain and main; using latter");
   }
   return mangle("mainCRTStartup");
 }
 
 WindowsSubsystem LinkerDriver::inferSubsystem() {
   if (config->dll)
     return IMAGE_SUBSYSTEM_WINDOWS_GUI;
   if (config->mingw)
static std::string createResponseFile(const opt::InputArgList &args,
 
   for (auto *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_linkrepro:
     case OPT_reproduce:
     case OPT_INPUT:
     case OPT_defaultlib:
     case OPT_libpath:
+    case OPT_winsysroot:
       break;
     case OPT_call_graph_ordering_file:
     case OPT_deffile:
     case OPT_manifestinput:
     case OPT_natvis:
       os << arg->getSpelling() << quote(rewritePath(arg->getValue())) << '\n';
       break;
     case OPT_order: {
case OPT_pdbstream: {
          << quote(rewritePath(nameFile.second)) << '\n';
       break;
     }
     case OPT_implib:
     case OPT_manifestfile:
     case OPT_pdb:
     case OPT_pdbstripped:
     case OPT_out:
-      os << arg->getSpelling() << sys::path::filename(arg->getValue()) << "\n";
+      os << arg->getSpelling() << path::filename(arg->getValue()) << "\n";
       break;
     default:
       os << toString(*arg) << "\n";
     }
   }
 
   for (StringRef path : searchPaths) {
     std::string relPath = relativeToRoot(path);
static std::string getMapFile(const opt::InputArgList &args,
   StringRef outFile = config->outputFile;
   return (outFile.substr(0, outFile.rfind('.')) + ".map").str();
 }
 
 static std::string getImplibPath() {
   if (!config->implib.empty())
     return std::string(config->implib);
   SmallString<128> out = StringRef(config->outputFile);
-  sys::path::replace_extension(out, ".lib");
+  path::replace_extension(out, ".lib");
   return std::string(out.str());
 }
 
 // The import name is calculated as follows:
 //
 //        | LIBRARY w/ ext |   LIBRARY w/o ext   | no LIBRARY
 //   -----+----------------+---------------------+------------------
 //   LINK | {value}        | {value}.{.dll/.exe} | {output name}
 //    LIB | {value}        | {value}.dll         | {output name}.dll
 //
 static std::string getImportName(bool asLib) {
   SmallString<128> out;
 
   if (config->importName.empty()) {
-    out.assign(sys::path::filename(config->outputFile));
+    out.assign(path::filename(config->outputFile));
     if (asLib)
-      sys::path::replace_extension(out, ".dll");
+      path::replace_extension(out, ".dll");
   } else {
     out.assign(config->importName);
-    if (!sys::path::has_extension(out))
-      sys::path::replace_extension(out,
-                                   (config->dll || asLib) ? ".dll" : ".exe");
+    if (!path::has_extension(out))
+      path::replace_extension(out, (config->dll || asLib) ? ".dll" : ".exe");
   }
 
   return std::string(out.str());
 }
 
 static void createImportLibrary(bool asLib) {
   std::vector<COFFShortExport> exports;
   for (Export &e1 : config->exports) {
static void createImportLibrary(bool asLib) {
   if (!oldBuf) {
     checkError(writeImportLibrary(libName, path, exports, config->machine,
                                   config->mingw));
     return;
   }
 
   SmallString<128> tmpName;
   if (std::error_code ec =
-          sys::fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
+          fs::createUniqueFile(path + ".tmp-%%%%%%%%.lib", tmpName))
     fatal("cannot create temporary file for import library " + path + ": " +
           ec.message());
 
   if (Error e = writeImportLibrary(libName, tmpName, exports, config->machine,
                                    config->mingw)) {
     checkError(std::move(e));
     return;
   }
 
   std::unique_ptr<MemoryBuffer> newBuf = check(MemoryBuffer::getFile(
       tmpName, /*IsText=*/false, /*RequiresNullTerminator=*/false));
   if ((*oldBuf)->getBuffer() != newBuf->getBuffer()) {
     oldBuf->reset();
-    checkError(errorCodeToError(sys::fs::rename(tmpName, path)));
+    checkError(errorCodeToError(fs::rename(tmpName, path)));
   } else {
-    sys::fs::remove(tmpName);
+    fs::remove(tmpName);
   }
 }
 
 static void parseModuleDefs(StringRef path) {
   std::unique_ptr<MemoryBuffer> mb =
       CHECK(MemoryBuffer::getFile(path, /*IsText=*/false,
                                   /*RequiresNullTerminator=*/false,
                                   /*IsVolatile=*/true),

 // link.exe replaces each %foo% in altPath with the contents of environment
 // variable foo, and adds the two magic env vars _PDB (expands to the basename
 // of pdb's output path) and _EXT (expands to the extension of the output
 // binary).
 // lld only supports %_PDB% and %_EXT% and warns on references to all other env
 // vars.
 static void parsePDBAltPath(StringRef altPath) {
   SmallString<128> buf;
-  StringRef pdbBasename =
-      sys::path::filename(config->pdbPath, sys::path::Style::windows);
+  StringRef pdbBasename = path::filename(config->pdbPath, path::Style::windows);
   StringRef binaryExtension =
-      sys::path::extension(config->outputFile, sys::path::Style::windows);
+      path::extension(config->outputFile, path::Style::windows);
   if (!binaryExtension.empty())
     binaryExtension = binaryExtension.substr(1); // %_EXT% does not include '.'.
 
   // Invariant:
   //   +--------- cursor ('a...' might be the empty string).
   //   |   +----- firstMark
   //   |   |   +- secondMark
   //   v   v   v

 // name while /reproduce takes a full path. We have /linkrepro for compatibility
 // with Microsoft link.exe.
 Optional<std::string> getReproduceFile(const opt::InputArgList &args) {
   if (auto *arg = args.getLastArg(OPT_reproduce))
     return std::string(arg->getValue());
 
   if (auto *arg = args.getLastArg(OPT_linkrepro)) {
     SmallString<64> path = StringRef(arg->getValue());
-    sys::path::append(path, "repro.tar");
+    path::append(path, "repro.tar");
     return std::string(path);
   }
 
   // This is intentionally not guarded by OPT_lldignoreenv since writing
   // a repro tar file doesn't affect the main output.
   if (auto *path = getenv("LLD_REPRODUCE"))
     return std::string(path);
 
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
 
   // Handle /lldmingw early, since it can potentially affect how other
   // options are handled.
   config->mingw = args.hasArg(OPT_lldmingw);
 
   // Handle /linkrepro and /reproduce.
   if (Optional<std::string> path = getReproduceFile(args)) {
     Expected<std::unique_ptr<TarWriter>> errOrWriter =
-        TarWriter::create(*path, sys::path::stem(*path));
+        TarWriter::create(*path, path::stem(*path));
 
     if (errOrWriter) {
       tar = std::move(*errOrWriter);
     } else {
       error("/linkrepro: failed to open " + *path + ": " +
             toString(errOrWriter.takeError()));
     }
   }
 
   if (!args.hasArg(OPT_INPUT, OPT_wholearchive_file)) {
     if (args.hasArg(OPT_deffile))
       config->noEntry = true;
     else
       fatal("no input files");
   }
 
   // Construct search path list.
   searchPaths.push_back("");
   for (auto *arg : args.filtered(OPT_libpath))
     searchPaths.push_back(arg->getValue());
+  if (auto *arg = args.getLastArg(OPT_winsysroot))
+    addWinSysRootLibSearchPaths(arg->getValue());
   if (!args.hasArg(OPT_lldignoreenv))
     addLibSearchPaths();
 
   // Handle /ignore
   for (auto *arg : args.filtered(OPT_ignore)) {
     SmallVector<StringRef, 8> vec;
     StringRef(arg->getValue()).split(vec, ',');
     for (StringRef s : vec) {
if (config->incremental && config->doICF != ICFLevel::None) {
     warn("ignoring '/incremental' because ICF is enabled; use '/opt:noicf' to "
          "disable");
     config->incremental = false;
   }
 
   if (errorCount())
     return;
 
-  std::set<sys::fs::UniqueID> wholeArchives;
+  std::set<fs::UniqueID> wholeArchives;
   for (auto *arg : args.filtered(OPT_wholearchive_file))
     if (Optional<StringRef> path = doFindFile(arg->getValue()))
-      if (Optional<sys::fs::UniqueID> id = getUniqueID(*path))
+      if (Optional<fs::UniqueID> id = getUniqueID(*path))
         wholeArchives.insert(*id);
 
   // A predicate returning true if a given path is an argument for
   // /wholearchive:, or /wholearchive is enabled globally.
   // This function is a bit tricky because "foo.obj /wholearchive:././foo.obj"
   // needs to be handled as "/wholearchive:foo.obj foo.obj".
   auto isWholeArchive = [&](StringRef path) -> bool {
     if (args.hasArg(OPT_wholearchive_flag))
       return true;
-    if (Optional<sys::fs::UniqueID> id = getUniqueID(path))
+    if (Optional<fs::UniqueID> id = getUniqueID(path))
       return wholeArchives.count(*id);
     return false;
   };
 
   // Create a list of input files. These can be given as OPT_INPUT options
   // and OPT_wholearchive_file options, and we also need to track OPT_start_lib
   // and OPT_end_lib.
   bool inLib = false;
if (auto e = tryCreateFile(config->outputFile)) {
     error("cannot open output file " + config->outputFile + ": " + e.message());
     return;
   }
 
   if (shouldCreatePDB) {
     // Put the PDB next to the image if no /pdb flag was passed.
     if (config->pdbPath.empty()) {
       config->pdbPath = config->outputFile;
-      sys::path::replace_extension(config->pdbPath, ".pdb");
+      path::replace_extension(config->pdbPath, ".pdb");
     }
 
     // The embedded PDB path should be the absolute path to the PDB if no
     // /pdbaltpath flag was passed.
     if (config->pdbAltPath.empty()) {
       config->pdbAltPath = config->pdbPath;
 
       // It's important to make the path absolute and remove dots.  This path
       // will eventually be written into the PE header, and certain Microsoft
       // tools won't work correctly if these assumptions are not held.
-      sys::fs::make_absolute(config->pdbAltPath);
-      sys::path::remove_dots(config->pdbAltPath);
+      fs::make_absolute(config->pdbAltPath);
+      path::remove_dots(config->pdbAltPath);
     } else {
       // Don't do this earlier, so that Config->OutputFile is ready.
       parsePDBAltPath(config->pdbAltPath);
     }
   }
 
   // Set default image base if /base is not given.
   if (config->imageBase == uint64_t(-1))

lld/COFF/Options.td

 def section : P<"section", "Specify section attributes">;
 def stack   : P<"stack", "Size of the stack">;
 def stub    : P<"stub", "Specify DOS stub file">;
 def subsystem : P<"subsystem", "Specify subsystem">;
 def timestamp : P<"timestamp", "Specify the PE header timestamp">;
 def version : P<"version", "Specify a version number in the PE header">;
 def wholearchive_file : P<"wholearchive",
     "Include all object files from this library">;
+def winsysroot : P<"winsysroot",
+    "Adds several subdirectories to the library search paths">;
 
 def disallowlib : Joined<["/", "-", "/?", "-?"], "disallowlib:">,
     Alias<nodefaultlib>;
 
 def manifest : F<"manifest">, HelpText<"Create .manifest file">;
 def manifest_colon : P<
     "manifest",
     "NO disables manifest output; EMBED[,ID=#] embeds manifest as resource in the image">;