Define sys::path::convert_to_slash.

[ruiu]

Summary

This patch moves convertToUnixPathSeparator from LLD to LLVM.

[silvas]

can you put the declaration/definition closer to sys::path::native? Other than that this LGTM.

[ruiu]

Sean,

I'm reluctant to change this type from std::string convert_to_slashes(StringRef) to void convert_to_slashes(SmallVectorImpl<char> &) as the former is easier to use than the latter. In some cases, you can avoid string copy with the latter type, but I think that's very important here. I don't want to optimize unless it is needed.

[silvas]

In D28444#639425, @ruiu wrote:

Sean,

I'm reluctant to change this type from std::string convert_to_slashes(StringRef) to void convert_to_slashes(SmallVectorImpl<char> &) as the former is easier to use than the latter. In some cases, you can avoid string copy with the latter type, but I think that's very important here. I don't want to optimize unless it is needed.

Sorry for the confusion, I didn't mean to change the signature. By "put the declaration/definition closer" I literally just meant to move the lines of code within the file so that they are nearby.

[ruiu]

Ah. I made that change and submitted as r291414. Thanks.

lld/trunk/include/lld/Core/Reproduce.h

 std::string quote(StringRef S);
 
 // Rewrite the given path if a file exists with that pathname, otherwise
 // returns the original path.
 std::string rewritePath(StringRef S);
 
 // Returns the string form of the given argument.
 std::string toString(llvm::opt::Arg *Arg);
-
-// Replaces backslashes with slashes if Windows.
-std::string convertToUnixPathSeparator(StringRef S);
 }
 
 #endif

lld/trunk/lib/Core/Reproduce.cpp

std::string lld::relativeToRoot(StringRef Path) {
   SmallString<128> Res;
   StringRef Root = path::root_name(Abs);
   if (Root.endswith(":"))
     Res = Root.drop_back();
   else if (Root.startswith("//"))
     Res = Root.substr(2);
 
   path::append(Res, path::relative_path(Abs));
-  return convertToUnixPathSeparator(Res);
+  return path::convert_to_slash(Res);
 }
 
 // Quote a given string if it contains a space character.
 std::string lld::quote(StringRef S) {
   if (S.find(' ') == StringRef::npos)
     return S;
   return ("\"" + S + "\"").str();
 }
 
 std::string lld::rewritePath(StringRef S) {
   if (fs::exists(S))
     return relativeToRoot(S);
   return S;
 }
 
 std::string lld::toString(opt::Arg *Arg) {
   std::string K = Arg->getSpelling();
   if (Arg->getNumValues() == 0)
     return K;
   std::string V = quote(Arg->getValue());
   if (Arg->getOption().getRenderStyle() == opt::Option::RenderJoinedStyle)
     return K + V;
   return K + " " + V;
 }
-
-std::string lld::convertToUnixPathSeparator(StringRef S) {
-#ifdef LLVM_ON_WIN32
-  std::string Ret = S.str();
-  std::replace(Ret.begin(), Ret.end(), '\\', '/');
-  return Ret;
-#else
-  return S;
-#endif
-}

llvm/trunk/include/llvm/Support/Path.h

 
 /// Convert path to the native form in place. This is used to give paths to
 /// users and operating system calls in the platform's normal way. For example,
 /// on Windows all '/' are converted to '\'.
 ///
 /// @param path A path that is transformed to native format.
 void native(SmallVectorImpl<char> &path);
 
+/// @brief Replaces backslashes with slashes if Windows.
+///
+/// @param path processed path
+/// @result The result of replacing backslashes with forward slashes if Windows.
+/// On Unix, this function is a no-op because backslashes are valid path
+/// chracters.
+std::string convert_to_slash(StringRef path);
+
 /// @}
 /// @name Lexical Observers
 /// @{
 
 /// @brief Get root name.
 ///
 /// @code
 ///   //net/hello => //net

llvm/trunk/lib/Support/Path.cpp

if (*PI == '\\') {
         ++PI; // increment once, the for loop will move over the escaped slash
       else
         *PI = '/';
     }
   }
 #endif
 }
 
+std::string convert_to_slash(StringRef path) {
+#ifdef LLVM_ON_WIN32
+  std::string s = path.str();
+  std::replace(s.begin(), s.end(), '\\', '/');
+  return s;
+#else
+  return path;
+#endif
+}
+
 StringRef filename(StringRef path) {
   return *rbegin(path);
 }
 
 StringRef stem(StringRef path) {
   StringRef fname = filename(path);
   size_t pos = fname.find_last_of('.');
   if (pos == StringRef::npos)

llvm/trunk/lib/Support/TarWriter.cpp

 // https://www.freebsd.org/cgi/man.cgi?query=tar&sektion=5
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/TarWriter.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Path.h"
 
 using namespace llvm;
 
 // Each file in an archive must be aligned to this block size.
 static const int BlockSize = 512;
 
 struct UstarHeader {
   char Name[100];
static void writeUstarHeader(raw_fd_ostream &OS, StringRef Path, size_t Size) {
   memcpy(Hdr.Mode, "0000664", 8);
   snprintf(Hdr.Size, sizeof(Hdr.Size), "%011zo", Size);
   memcpy(Hdr.Magic, "ustar", 6);
   memcpy(Hdr.Prefix, Prefix.data(), Prefix.size());
   computeChecksum(Hdr);
   OS << StringRef(reinterpret_cast<char *>(&Hdr), sizeof(Hdr));
 }
 
-// We want to use '/' as a path separator even on Windows.
-// This function canonicalizes a given path.
-static std::string canonicalize(std::string S) {
-#ifdef LLVM_ON_WIN32
-  std::replace(S.begin(), S.end(), '\\', '/');
-#endif
-  return S;
-}
-
 // Creates a TarWriter instance and returns it.
 Expected<std::unique_ptr<TarWriter>> TarWriter::create(StringRef OutputPath,
                                                        StringRef BaseDir) {
   int FD;
   if (std::error_code EC = openFileForWrite(OutputPath, FD, sys::fs::F_None))
     return make_error<StringError>("cannot open " + OutputPath, EC);
   return std::unique_ptr<TarWriter>(new TarWriter(FD, BaseDir));
 }
 
 TarWriter::TarWriter(int FD, StringRef BaseDir)
     : OS(FD, /*shouldClose=*/true, /*unbuffered=*/false), BaseDir(BaseDir) {}
 
 // Append a given file to an archive.
 void TarWriter::append(StringRef Path, StringRef Data) {
   // Write Path and Data.
-  std::string S = BaseDir + "/" + canonicalize(Path) + "\0";
+  std::string S = BaseDir + "/" + sys::path::convert_to_slash(Path) + "\0";
   if (fitsInUstar(S)) {
     writeUstarHeader(OS, S, Data.size());
   } else {
     writePaxHeader(OS, S);
     writeUstarHeader(OS, "", Data.size());
   }
 
   OS << Data;