[Driver] Use forward slashes in most linker arguments

[mstorsjo]

Summary

libtool inspects the output of $CC -v to detect what object files and libraries are linked in by default. When clang is built as a native windows executable, all paths are formatted with backslashes, and the backslashes cause each argument to be enclosed in quotes. The backslashes and quotes break further processing within libtool (which is implemented in shell script, running in e.g. msys) pretty badly.

Between unix style pathes (that only work in tools that are linked to the msys runtime, essentially the same as cygwin) and proper windows style paths (with backslashes, that can easily break shell scripts and msys environments), the best compromise is to use windows style paths (starting with e.g. c:) but with forward slashes, which both msys based tools, shell scripts and native windows executables can cope with. This incidentally turns out to be the form of paths that GCC prints out when run with -v on windows as well.

This change potentially makes the output from clang -v a bit more inconsistent, but it is isn't necessarily very consistent to begin with.

[mstorsjo]

Ping @rnk or others with good ideas

[rnk]

lib/Driver/Job.cpp

104–105 ↗

(On Diff #168958)

This is blindly treating every argument as if it were a path. I can imagine someone wanting to define a macro to a string value containing backslashes, such as: -DAWESOME_MACRO="\"asdf\""
Given that this is used for -### and crash diagnostic printing, I'm hesitant to do this here. I think it might be better to, in a cygming environment, try to convert all our paths to forward slashes before we add them to the command line.

[mstorsjo]

lib/Driver/Job.cpp

104–105 ↗

(On Diff #168958)

A quick test of the concept is at http://martin.st/temp/clang-forward-slash.patch; this seems to be roughly enough to get forward slashes for all paths in the linker command at least. Does this look like what you have in mind?

For a plain "clang -v test.c", this takes care of everything except the temporary object file. It doesn't do anything for the compile command though. This should be roughly the minimal amount needed for this particular case of libtool, but then again makes the -v output wildly inconsistent.

Changing the path separator earlier would kinda require changing the preferred path separator throughout all callsites to any path api, or change the path utils to allow overriding the global default somehow.

[rnk]

lib/Driver/Job.cpp

104–105 ↗

(On Diff #168958)

I think our output is already pretty inconsistent. Most build systems use forward slash paths internally, so that's what the compiler sees on the command line. Then, we dutifully take those paths and join them with the "preferred" separator (\), and make paths with mixed slashes, which nobody wants.

I would go with the patch you put forward, if that solves the issue. Everything there is very gnu toolchain oriented, it makes sense to try to match their path style.

The one change I might object to is ToolChain::GetProgramPath, since cmd really wants the name of the program to have back slashes. As long as that comes out with backslashes in -### and crash report .sh files, I'd be OK with it.

[mstorsjo]

lib/Driver/Job.cpp

104–105 ↗

(On Diff #168958)

Ok, thanks - I'll test run things with that patch (minus the executable change) and update this review properly later then.

[mstorsjo]

Tested the earlier discussed solution, and it seems to work fine for my particular case with libtool.

[mstorsjo]

Ping @rnk

[rnk]

lgtm

[mstorsjo]

So, this failed due to some tests expecting to find the exact same path substring in different parts of the output (used with FileCheck captured variables): http://lab.llvm.org:8011/builders/clang-x64-windows-msvc/builds/763

What's the best course of action here - trying to extend the changes to forward slashes in more places, to make these tests pass, or adjust the tests to not break due to this? Or extend FileCheck to allow checks for "similar text, modulo path separator differences"? :-)

[mstorsjo]

Converting more path instances, enough to fix the tests that failed on windows bots. The patch is not very pretty, though...

[zturner]

lib/Driver/Driver.cpp

1013–1014 ↗

(On Diff #170755)

Is this going to affect the cl driver as well?

lib/Driver/ToolChain.cpp

381 ↗

(On Diff #170755)

Same questions here and for the rest of the changes in this file

[rnk]

lib/Driver/Driver.cpp

1013–1014 ↗

(On Diff #170755)

Yeah, if we change the resource dir, I think it's going to have knock-on affects to the debug info we emit to describe the locations of compiler intrinsic headers. I was imagining that this would be limited to flags which only get passed to GNU-ld-compatible linkers.

[mstorsjo]

lib/Driver/Driver.cpp

1013–1014 ↗

(On Diff #170755)

Well, the first minimal version that was committed in rL345004 was enough to produce paths that worked with libtool, but I guess that one also would cause some amount of changes for the cl driver.

Now in order for all the tests to pass, I had to change (almost) all of these as I have here. (After rechecking, I think I can spare one or two of them.)

But I do have to touch ResourceDir for test/Driver/linux-per-target-runtime-dir.c to pass, since it requires that a -resource-dir parameter matches a later -L linker flag, and I do need to change the -L linker flag for the libtool case.

So I guess it's back to the drawing board with this change then. What do you guys think is the path of least impact on e.g. the cl driver and PDB generation in general (and least messy scattered rewrites), without breaking a bunch of tests (e.g. test/Driver/linux-ld.c requires the --sysroot parameter to match -L), while still getting libtool compatible paths with forward slashes out of -v. At least when targeting mingw, but maybe ideally for any non-msvc target? For cross compiling for a linux target from windows, I would guess forward slashes would be preferred as well.

[zturner]

It seems like some combination of checking the target triple, host triple,
and driver mode and putting the conversions behind those checks could work?

For paths like resource dir that are going into debug info it should be
driver mode. For paths we pass to another tool it should probably be based
on target triple . This probably isn’t perfect, but WDYT?

[mstorsjo]

In D53066#1274288, @zturner wrote:

It seems like some combination of checking the target triple, host triple,
and driver mode and putting the conversions behind those checks could work?

Sounds ok, I can give it a shot. There's probably no need to explicitly check the host here, as the convert_to_slash function is a no-op on anything else than windows.

For paths like resource dir that are going into debug info it should be
driver mode.

Why is that? Wouldn't one want the same behaviour when building with the clang driver with an msvc target triple? Also, what kind of paths do you get in the PDB when crosscompiling from unix with clang-cl?

[mstorsjo]

Changed so that we only rewrite paths if targeting a non-windows OS, or cygwin/mingw. Since convert_to_slash is a no-op when running on anything else than windows, this should hit exactly the cases where converting to forward slashes should make sense.

[rnk]

lgtm

[mstorsjo]

Nope, still no really working properly with all the tests out there (I had only run the Driver subdirectory since I'm only testing in a very underpowered VM, and it had skipped the cuda/hip tests which also seemed to have a few issues):
http://lab.llvm.org:8011/builders/llvm-clang-x86_64-expensive-checks-win/builds/13562
http://lab.llvm.org:8011/builders/clang-x64-windows-msvc/builds/886
http://lab.llvm.org:8011/builders/llvm-clang-lld-x86_64-scei-ps4-windows10pro-fast/builds/20994

I could potentially make all the tests in Driver work by continuing doing whack-a-mole for normalizing all paths in places where they are matched in tests, but this also failed some tests in CodeGen/thinlto which I haven't studied closer yet. It also seems to break tests in clang-tidy/clangd. So this doesn't really seem sustainable unless we do it completely thoroughly all over the place, but given cross-project dependencies, it looks like that is a much much larger scope change that I probably don't have time to pusue.

What other options are there? The actual original problem (libtool) I'm trying to solve only requires paths in this form in the output of clang -v (for linking). I guess that one could be worked around by scaling the change back to one of the original versions where I only changed a couple paths, and making that change conditional on -v being set (plus conditional on target as it is right now). Having that behave differently than -### as used in most tests, isn't really nice though, but if we change the output of -###, we're back at whack-a-mole.

[rupprecht]

I'm not familiar with this code or anything windows related, and it looks like @rnk is, so I'll remove myself and let him approve

[rnk]

We discussed adding a new path style that opts into a / preferred separator on Windows, something like path::Style::windows_forward. All of the absolute path handling routines would behave the same, but the preferred separator would now be /. We can make the default path style for mingw be mingw_forward.

clang/include/clang/Driver/ToolChain.h

 #include "clang/Driver/Multilib.h"
 #include "clang/Driver/Types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Target/TargetOptions.h"
 #include <cassert>
 #include <memory>
 #include <string>
 #include <utility>
 
 namespace llvm {
public:
   virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     bool Shared = false) const;
 
   const char *getCompilerRTArgString(const llvm::opt::ArgList &Args,
                                      StringRef Component,
                                      bool Shared = false) const;
 
+  std::string normalizePath(StringRef Path) const {
+    if (!Triple.isOSWindows() || Triple.isOSCygMing())
+      return llvm::sys::path::convert_to_slash(Path);
+    return Path;
+  }
+
   // Returns <ResourceDir>/lib/<OSName>/<arch>.  This is used by runtimes (such
   // as OpenMP) to find arch-specific libraries.
   std::string getArchSpecificLibPath() const;
 
   // Returns <OSname> part of above.
   StringRef getOSLibName() const;
 
   /// needsProfileRT - returns true if instrumentation profile is on.

clang/lib/Driver/Driver.cpp

Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
 
   if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
     SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
                     .Case("cwd", SaveTempsCwd)
                     .Case("obj", SaveTempsObj)
                     .Default(SaveTempsCwd);
   }
 
+  llvm::Triple EffectiveTriple = computeTargetTriple(*this, TargetTriple, Args);
+  if (!EffectiveTriple.isOSWindows() || EffectiveTriple.isOSCygMing()) {
+    for (auto *Str : {&Dir, &InstalledDir, &SysRoot, &ResourceDir})
+      *Str = llvm::sys::path::convert_to_slash(*Str);
+  }
+
   setLTOMode(Args);
 
   // Process -fembed-bitcode= flags.
   if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
     StringRef Name = A->getValue();
     unsigned Model = llvm::StringSwitch<unsigned>(Name)
         .Case("off", EmbedNone)
         .Case("all", EmbedBitcode)

clang/lib/Driver/ToolChain.cpp

std::string ToolChain::getCompilerRT(const ArgList &Args, StringRef Component,
   const char *Prefix = IsITANMSVCWindows ? "" : "lib";
   const char *Suffix = Shared ? (Triple.isOSWindows() ? ".lib" : ".so")
                               : (IsITANMSVCWindows ? ".lib" : ".a");
   if (Shared && Triple.isWindowsGNUEnvironment())
     Suffix = ".dll.a";
 
   for (const auto &LibPath : getLibraryPaths()) {
     SmallString<128> P(LibPath);
-    llvm::sys::path::append(P, Prefix + Twine("clang_rt.") + Component + Suffix);
+    llvm::sys::path::append(P,
+                            Prefix + Twine("clang_rt.") + Component + Suffix);
     if (getVFS().exists(P))
-      return P.str();
+      return normalizePath(P);
   }
 
   StringRef Arch = getArchNameForCompilerRTLib(*this, Args);
   const char *Env = TT.isAndroid() ? "-android" : "";
   SmallString<128> Path(getCompilerRTPath());
   llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
                                     Arch + Env + Suffix);
-  return Path.str();
+  return normalizePath(Path);
 }
 
 const char *ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args,
                                               StringRef Component,
                                               bool Shared) const {
   return Args.MakeArgString(getCompilerRT(Args, Component, Shared));
 }
 
Tool *ToolChain::SelectTool(const JobAction &JA) const {
   if (getDriver().ShouldUseClangCompiler(JA)) return getClang();
   Action::ActionClass AC = JA.getKind();
   if (AC == Action::AssembleJobClass && useIntegratedAs())
     return getClangAs();
   return getTool(AC);
 }
 
 std::string ToolChain::GetFilePath(const char *Name) const {
-  return D.GetFilePath(Name, *this);
+  return normalizePath(D.GetFilePath(Name, *this));
 }
 
 std::string ToolChain::GetProgramPath(const char *Name) const {
   return D.GetProgramPath(Name, *this);
 }
 
 std::string ToolChain::GetLinkerPath() const {
   const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
case ToolChain::CST_Libstdcxx:
     CmdArgs.push_back("-lstdc++");
     break;
   }
 }
 
 void ToolChain::AddFilePathLibArgs(const ArgList &Args,
                                    ArgStringList &CmdArgs) const {
   for (const auto &LibPath : getLibraryPaths())
-    if(LibPath.length() > 0)
-      CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+    if (LibPath.length() > 0)
+      CmdArgs.push_back(
+          Args.MakeArgString(StringRef("-L") + normalizePath(LibPath)));
 
   for (const auto &LibPath : getFilePaths())
-    if(LibPath.length() > 0)
-      CmdArgs.push_back(Args.MakeArgString(StringRef("-L") + LibPath));
+    if (LibPath.length() > 0)
+      CmdArgs.push_back(
+          Args.MakeArgString(StringRef("-L") + normalizePath(LibPath)));
 }
 
 void ToolChain::AddCCKextLibArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-lcc_kext");
 }
 
 bool ToolChain::AddFastMathRuntimeIfAvailable(const ArgList &Args,

clang/lib/Driver/ToolChains/Clang.cpp

if (Output.getType() == types::TY_Dependencies) {
       CmdArgs.push_back(Output.getFilename());
     } else {
       assert(Output.isNothing() && "Input output.");
     }
 
     for (const auto &II : Inputs) {
       addDashXForInput(Args, II, CmdArgs);
       if (II.isFilename())
-        CmdArgs.push_back(II.getFilename());
+        CmdArgs.push_back(
+            Args.MakeArgString(TC.normalizePath(II.getFilename())));
       else
         II.getInputArg().renderAsInput(Args, CmdArgs);
     }
 
     C.addCommand(llvm::make_unique<Command>(JA, *this, D.getClangProgramPath(),
                                             CmdArgs, Inputs));
     return;
   }
if (C.getDriver().isSaveTempsEnabled() &&
       !(C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO()) &&
       isa<CompileJobAction>(JA))
     CmdArgs.push_back("-disable-llvm-passes");
 
   if (Output.getType() == types::TY_Dependencies) {
     // Handled with other dependency code.
   } else if (Output.isFilename()) {
     CmdArgs.push_back("-o");
-    CmdArgs.push_back(Output.getFilename());
+    CmdArgs.push_back(
+        Args.MakeArgString(TC.normalizePath(Output.getFilename())));
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   addDashXForInput(Args, Input, CmdArgs);
 
   ArrayRef<InputInfo> FrontendInputs = Input;
   if (IsHeaderModulePrecompile)
     FrontendInputs = ModuleHeaderInputs;
   else if (Input.isNothing())
     FrontendInputs = {};
 
   for (const InputInfo &Input : FrontendInputs) {
     if (Input.isFilename())
-      CmdArgs.push_back(Input.getFilename());
+      CmdArgs.push_back(
+          Args.MakeArgString(TC.normalizePath(Input.getFilename())));
     else
       Input.getInputArg().renderAsInput(Args, CmdArgs);
   }
 
   Args.AddAllArgs(CmdArgs, options::OPT_undef);
 
   const char *Exec = D.getClangProgramPath();
 
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
                            const InputInfo &Output, const InputInfoList &Inputs,
                            const ArgList &Args,
                            const char *LinkingOutput) const {
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
-  const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
+  const ToolChain &TC = getToolChain();
+  const llvm::Triple &Triple = TC.getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();
-  const auto &D = getToolChain().getDriver();
+  const auto &D = TC.getDriver();
 
   // Don't warn about "clang -w -c foo.s"
   Args.ClaimAllArgs(options::OPT_w);
   // and "clang -emit-llvm -c foo.s"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 
   claimNoWarnArgs(Args);
 
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
 
   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
                                     getToolChain().getDriver());
 
   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
 
   assert(Output.isFilename() && "Unexpected lipo output.");
   CmdArgs.push_back("-o");
-  CmdArgs.push_back(Output.getFilename());
+  CmdArgs.push_back(Args.MakeArgString(TC.normalizePath(Output.getFilename())));
 
   const llvm::Triple &T = getToolChain().getTriple();
   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
       (T.isOSLinux() || T.isOSFuchsia())) {
     CmdArgs.push_back("-split-dwarf-file");
     CmdArgs.push_back(SplitDebugName(Args, Input));
   }
 
   assert(Input.isFilename() && "Invalid input.");
-  CmdArgs.push_back(Input.getFilename());
+  CmdArgs.push_back(Args.MakeArgString(TC.normalizePath(Input.getFilename())));
 
   const char *Exec = getToolChain().getDriver().getClangProgramPath();
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 // Begin OffloadBundler
 
 void OffloadBundler::ConstructJob(Compilation &C, const JobAction &JA,

clang/lib/Driver/ToolChains/CommonArgs.cpp

if (auto *IA = II.getAction())
         continue;
 
     if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(II.getType()))
       // Don't try to pass LLVM inputs unless we have native support.
       D.Diag(diag::err_drv_no_linker_llvm_support) << TC.getTripleString();
 
     // Add filenames immediately.
     if (II.isFilename()) {
-      CmdArgs.push_back(II.getFilename());
+      CmdArgs.push_back(Args.MakeArgString(TC.normalizePath(II.getFilename())));
       continue;
     }
 
     // Otherwise, this is a linker input argument.
     const Arg &A = II.getInputArg();
 
     // Handle reserved library options.
     if (A.getOption().matches(options::OPT_Z_reserved_lib_stdcxx))

clang/lib/Driver/ToolChains/Gnu.cpp

void Generic_GCC::GCCInstallationDetector::init(
   SmallVector<std::string, 8> Prefixes(D.PrefixDirs.begin(),
                                        D.PrefixDirs.end());
 
   StringRef GCCToolchainDir = getGCCToolchainDir(Args, D.SysRoot);
   if (GCCToolchainDir != "") {
     if (GCCToolchainDir.back() == '/')
       GCCToolchainDir = GCCToolchainDir.drop_back(); // remove the /
 
-    Prefixes.push_back(GCCToolchainDir);
+    Prefixes.push_back(llvm::sys::path::convert_to_slash(GCCToolchainDir));
   } else {
     // If we have a SysRoot, try that first.
     if (!D.SysRoot.empty()) {
       Prefixes.push_back(D.SysRoot);
       AddDefaultGCCPrefixes(TargetTriple, Prefixes, D.SysRoot);
     }
 
     // Then look for gcc installed alongside clang.