[ThinLTO] Option to control path of distributed backend files

[tejohnson]

Summary

Add new thinlto-prefix-replace plugin option to control where files
for a distributed backend (the individual index files and optional
imports files) are created.

If specified, expects a string of the form "oldprefix:newprefix", and
instead of generating these files in the same directory path as the
corresponding bitcode file, will use a path formed by replacing the
bitcode file's path prefix matching oldprefix with newprefix.

Depends on D19636.

[mehdi_amini]

test/tools/gold/X86/thinlto_prefix_replace.ll

4 ↗

(On Diff #55374)

Deserve a comment

tools/gold/gold-plugin.cpp

198 ↗

(On Diff #55374)

What is the motivation for that?

[tejohnson]

test/tools/gold/X86/thinlto_prefix_replace.ll

4 ↗

(On Diff #55374)

Will add.

tools/gold/gold-plugin.cpp

198 ↗

(On Diff #55374)

In our particular instance it helps enable sharing of bitcode files across builds of different libraries or binaries. I.e. the bitcode files, the result of the first compile step, are output into one tree. When the ThinLTO link and backend steps execute, we want the resulting index/imports files to go into a different tree specific to the target binary/library. That way the same bitcode tree can be used as input across builds for multiple libraries/binaries. But this generally seems like useful functionality to allow flexibility in the build system.

[tejohnson]

Add comment to test. Rebase.

[mehdi_amini]

Can this be exposed to llvm-lto as well? It'll help testing when refactoring everything behind a new API.

test/tools/gold/X86/thinlto_prefix_replace.ll

13 ↗

(On Diff #55592)

I think you can just write ls %T/newpath/thinlto_prefix_replace.o.thinlto.bc without any FileCheck, it should be enough to test the existence of the file.

[tejohnson]

In D19644#421629, @joker.eph wrote:

Can this be exposed to llvm-lto as well? It'll help testing when refactoring everything behind a new API.

I wasn't sure the best way to do that initially, but thinking some more I think this is what I can do: In D19556 (individual index files) I will sink the lifetime of the raw_fd_ostream into WriteIndexToFile (similar to how it is done within EmitImportsFiles in D19636). Then I can move getOutputModulePath into FunctionImport.cpp as well, and just pass the new and old prefix into those routines and do the replacement there before opening the files.

test/tools/gold/X86/thinlto_prefix_replace.ll

13 ↗

(On Diff #55592)

Ok, will give that a try.

[tejohnson]

In D19644#421867, @tejohnson wrote:

In D19644#421629, @joker.eph wrote:

Can this be exposed to llvm-lto as well? It'll help testing when refactoring everything behind a new API.

I wasn't sure the best way to do that initially, but thinking some more I think this is what I can do: In D19556 (individual index files) I will sink the lifetime of the raw_fd_ostream into WriteIndexToFile (similar to how it is done within EmitImportsFiles in D19636). Then I can move getOutputModulePath into FunctionImport.cpp as well, and just pass the new and old prefix into those routines and do the replacement there before opening the files.

I remembered why I didn't do this - what I describe above doesn't work since WriteIndexToFile is in the bitcode writer, and I don't want to add a dependence from it to the function importer or vice versa. It's difficult to sink the code here, which is just doing path and file operations, into the function importer since the result is used both by EmitImports (in the function importer) and for WriteIndexToFile (in the bitcode writer).

What I did instead was to extract the path manipulation done here to replace the matching path prefix with a new prefix into a new path method in libSupport (and added unit tests). I then invoke that both from gold-plugin as well as from llvm-lto. There is some code duplicated between gold-plugin and llvm-lto but it is now pretty minimal (just invoking some basic option parsing and the path support library routines). I added a companion llvm-lto test as well.

[tejohnson]

Extract path manipulation into libSupport path helper, add unit tests. Add
similar support to llvm-lto along with test.

[tejohnson]

Forgot to add new llvm-lto based test in previous update, add it here.

[tejohnson]

Ping.
Thanks,
Teresa

[mehdi_amini]

LGTM, with some suggestions inline (no need to review again)

lib/Support/Path.cpp

533 ↗

(On Diff #56910)

You mentioned as precondition in the doc:

 @param Path If \a Path starts with \a OldPrefix modify to instead
///        start with \a NewPrefix.

Here you're still doing the check. I'd either assert or update the comment.

539 ↗

(On Diff #56910)

If OldPrefix.size() == NewPrefix.size() we have a possible fast-path in-place.
(the unittest should also be updated to test this case)

tools/gold/gold-plugin.cpp

1217 ↗

(On Diff #56910)

This is a user-supplied command line flag, if you assert he I'd expect it to be appropriately validated with a report_fatal_error (or equivalent) at parse time (line 226 above)

[mehdi_amini]

tools/llvm-lto/llvm-lto.cpp

331 ↗

(On Diff #56910)

The duplication with the gold plugin isn't great for these two functions.

[tejohnson]

lib/Support/Path.cpp

533 ↗

(On Diff #56910)

I think the code matches the description, which indicates that we only do the replacement if Path starts with OldPrefix. Here we are skipping the replacement if Path does not start with OldPrefix.

539 ↗

(On Diff #56910)

I can do that.

tools/gold/gold-plugin.cpp

1217 ↗

(On Diff #56910)

Ok

tools/llvm-lto/llvm-lto.cpp

331 ↗

(On Diff #56910)

Agree, but I couldn't figure out a good way to avoid that. They didn't seem general enough to move into lib/Support either.

[mehdi_amini]

lib/Support/Path.cpp

533 ↗

(On Diff #56910)

Somehow I missed the "If" in the comment when I copy/pasted... Nevermind!

tools/llvm-lto/llvm-lto.cpp

331 ↗

(On Diff #56910)

It is not critical if there was no convenient way.

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

 /// @endcode
 ///
 /// @param path A path that has its extension replaced with \a extension.
 /// @param extension The extension to be added. It may be empty. It may also
 ///                  optionally start with a '.', if it does not, one will be
 ///                  prepended.
 void replace_extension(SmallVectorImpl<char> &path, const Twine &extension);
 
+/// @brief Replace matching path prefix with another path.
+///
+/// @code
+///   /foo, /old, /new => /foo
+///   /old/foo, /old, /new => /new/foo
+///   /foo, <empty>, /new => /new/foo
+///   /old/foo, /old, <empty> => /foo
+/// @endcode
+///
+/// @param Path If \a Path starts with \a OldPrefix modify to instead
+///        start with \a NewPrefix.
+/// @param OldPrefix The path prefix to strip from \a Path.
+/// @param NewPrefix The path prefix to replace \a NewPrefix with.
+void replace_path_prefix(SmallVectorImpl<char> &Path,
+                         const StringRef &OldPrefix,
+                         const StringRef &NewPrefix);
+
 /// @brief Append to path.
 ///
 /// @code
 ///   /foo  + bar/f => /foo/bar/f
 ///   /foo/ + bar/f => /foo/bar/f
 ///   foo   + bar/f => foo/bar/f
 /// @endcode
 ///

llvm/trunk/lib/Support/Path.cpp

void replace_extension(SmallVectorImpl<char> &path, const Twine &extension) {
   // Append '.' if needed.
   if (ext.size() > 0 && ext[0] != '.')
     path.push_back('.');
 
   // Append extension.
   path.append(ext.begin(), ext.end());
 }
 
+void replace_path_prefix(SmallVectorImpl<char> &Path,
+                         const StringRef &OldPrefix,
+                         const StringRef &NewPrefix) {
+  if (OldPrefix.empty() && NewPrefix.empty())
+    return;
+
+  StringRef OrigPath(Path.begin(), Path.size());
+  if (!OrigPath.startswith(OldPrefix))
+    return;
+
+  // If prefixes have the same size we can simply copy the new one over.
+  if (OldPrefix.size() == NewPrefix.size()) {
+    std::copy(NewPrefix.begin(), NewPrefix.end(), Path.begin());
+    return;
+  }
+
+  StringRef RelPath = OrigPath.substr(OldPrefix.size());
+  SmallString<256> NewPath;
+  path::append(NewPath, NewPrefix);
+  path::append(NewPath, RelPath);
+  Path.swap(NewPath);
+}
+
 void native(const Twine &path, SmallVectorImpl<char> &result) {
   assert((!path.isSingleStringRef() ||
           path.getSingleStringRef().data() != result.data()) &&
          "path and result are not allowed to overlap!");
   // Clear result.
   result.clear();
   path.toVector(result);
   native(result);

llvm/trunk/test/ThinLTO/X86/prefix_replace.ll

+; Check that changing the output path via prefix-replace works
+; RUN: mkdir -p %T/oldpath
+; RUN: opt -module-summary %s -o %T/oldpath/prefix_replace.o
+; Ensure that there is no existing file at the new path, so we properly
+; test the creation of the new file there.
+; RUN: rm -f %T/newpath/prefix_replace.o.thinlto.bc
+
+; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %T/oldpath/prefix_replace.o
+; RUN: llvm-lto -thinlto-action=distributedindexes -thinlto-prefix-replace="%T/oldpath/:%T/newpath/" -thinlto-index %t.index.bc %T/oldpath/prefix_replace.o
+
+; RUN: ls %T/newpath/prefix_replace.o.thinlto.bc
+
+define void @f() {
+entry:
+  ret void
+}

llvm/trunk/test/tools/gold/X86/thinlto_prefix_replace.ll

+; Check that changing the output path via thinlto-prefix-replace works
+; RUN: mkdir -p %T/oldpath
+; RUN: opt -module-summary %s -o %T/oldpath/thinlto_prefix_replace.o
+; Ensure that there is no existing file at the new path, so we properly
+; test the creation of the new file there.
+; RUN: rm -f %T/newpath/thinlto_prefix_replace.o.thinlto.bc
+; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
+; RUN:    --plugin-opt=thinlto \
+; RUN:    --plugin-opt=thinlto-index-only \
+; RUN:    --plugin-opt=thinlto-prefix-replace="%T/oldpath/:%T/newpath/" \
+; RUN:    -shared %T/oldpath/thinlto_prefix_replace.o -o %T/thinlto_prefix_replace
+; RUN: ls %T/newpath/thinlto_prefix_replace.o.thinlto.bc
+
+define void @f() {
+entry:
+  ret void
+}

llvm/trunk/tools/gold/gold-plugin.cpp

 #include "llvm/IR/Verifier.h"
 #include "llvm/Linker/IRMover.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ThreadPool.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/thread.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/FunctionImport.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
#endif
   // the import decisions, and exit afterwards. The assumption is
   // that the build system will launch the backend processes.
   static bool thinlto_index_only = false;
   // If true, when generating individual index files for distributed backends,
   // also generate a "${bitcodefile}.imports" file at the same location for each
   // bitcode file, listing the files it imports from in plain text. This is to
   // support distributed build file staging.
   static bool thinlto_emit_imports_files = false;
+  // Option to control where files for a distributed backend (the individual
+  // index files and optional imports files) are created.
+  // If specified, expects a string of the form "oldprefix:newprefix", and
+  // instead of generating these files in the same directory path as the
+  // corresponding bitcode file, will use a path formed by replacing the
+  // bitcode file's path prefix matching oldprefix with newprefix.
+  static std::string thinlto_prefix_replace;
   // Additional options to pass into the code generator.
   // Note: This array will contain all plugin options which are not claimed
   // as plugin exclusive to pass to the code generator.
   // For example, "generate-api-file" and "as"options are for the plugin
   // use only and will not be passed.
   static std::vector<const char *> extra;
 
   static void process_plugin_option(const char *opt_)
static void process_plugin_option(const char *opt_)
     } else if (opt == "disable-output") {
       TheOutputType = OT_DISABLE;
     } else if (opt == "thinlto") {
       thinlto = true;
     } else if (opt == "thinlto-index-only") {
       thinlto_index_only = true;
     } else if (opt == "thinlto-emit-imports-files") {
       thinlto_emit_imports_files = true;
+    } else if (opt.startswith("thinlto-prefix-replace=")) {
+      thinlto_prefix_replace = opt.substr(strlen("thinlto-prefix-replace="));
+      if (thinlto_prefix_replace.find(":") == std::string::npos)
+        message(LDPL_FATAL, "thinlto-prefix-replace expects 'old:new' format");
     } else if (opt.size() == 2 && opt[0] == 'O') {
       if (opt[1] < '0' || opt[1] > '3')
         message(LDPL_FATAL, "Optimization level must be between 0 and 3");
       OptLevel = opt[1] - '0';
     } else if (opt.startswith("jobs=")) {
       if (StringRef(opt_ + 5).getAsInteger(10, Parallelism))
         message(LDPL_FATAL, "Invalid parallelism level: %s", opt_ + 5);
     } else if (opt == "disable-verify") {
for (claimed_file &F : Modules) {
                          NewFilename.c_str(), TempOutFile);
     }
   }
 
   for (auto &Task : Tasks)
     Task.cleanup();
 }
 
+/// Parse the thinlto_prefix_replace option into the \p OldPrefix and
+/// \p NewPrefix strings, if it was specified.
+static void getThinLTOOldAndNewPrefix(std::string &OldPrefix,
+                                      std::string &NewPrefix) {
+  StringRef PrefixReplace = options::thinlto_prefix_replace;
+  assert(PrefixReplace.empty() || PrefixReplace.find(":") != StringRef::npos);
+  std::pair<StringRef, StringRef> Split = PrefixReplace.split(":");
+  OldPrefix = Split.first.str();
+  NewPrefix = Split.second.str();
+}
+
+/// Given the original \p Path to an output file, replace any path
+/// prefix matching \p OldPrefix with \p NewPrefix. Also, create the
+/// resulting directory if it does not yet exist.
+static std::string getThinLTOOutputFile(const std::string &Path,
+                                        const std::string &OldPrefix,
+                                        const std::string &NewPrefix) {
+  if (OldPrefix.empty() && NewPrefix.empty())
+    return Path;
+  SmallString<128> NewPath(Path);
+  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
+  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
+  if (!ParentPath.empty()) {
+    // Make sure the new directory exists, creating it if necessary.
+    if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
+      llvm::errs() << "warning: could not create directory '" << ParentPath
+                   << "': " << EC.message() << '\n';
+  }
+  return NewPath.str();
+}
+
 /// Perform ThinLTO link, which creates the combined index file.
 /// Also, either launch backend threads or (under thinlto-index-only)
 /// emit individual index files for distributed backends and exit.
 static ld_plugin_status thinLTOLink(raw_fd_ostream *ApiFile) {
   ModuleSummaryIndex CombinedIndex;
   uint64_t NextModuleId = 0;
   for (claimed_file &F : Modules) {
     PluginInputFile InputFile(F.handle);
if (options::thinlto_index_only) {
     // from gold as well, in which case this will be moved out of the
     // thinlto_index_only handling, and the function importer will be invoked
     // directly using the Lists.
     StringMap<FunctionImporter::ImportMapTy> ImportLists(NextModuleId);
     StringMap<FunctionImporter::ExportSetTy> ExportLists(NextModuleId);
     ComputeCrossModuleImport(CombinedIndex, ModuleToDefinedGVSummaries,
                              ImportLists, ExportLists);
 
+    // If the thinlto-prefix-replace option was specified, parse it and
+    // extract the old and new prefixes.
+    std::string OldPrefix, NewPrefix;
+    getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
+
     // For each input bitcode file, generate an individual index that
     // contains summaries only for its own global values, and for any that
     // should be imported.
     for (claimed_file &F : Modules) {
       PluginInputFile InputFile(F.handle);
       std::error_code EC;
-      raw_fd_ostream OS((Twine(InputFile.file().name) + ".thinlto.bc").str(),
-                        EC, sys::fs::OpenFlags::F_None);
+
+      std::string NewModulePath =
+          getThinLTOOutputFile(InputFile.file().name, OldPrefix, NewPrefix);
+      raw_fd_ostream OS((Twine(NewModulePath) + ".thinlto.bc").str(), EC,
+                        sys::fs::OpenFlags::F_None);
       if (EC)
         message(LDPL_FATAL, "Unable to open %s.thinlto.bc for writing: %s",
-                InputFile.file().name, EC.message().c_str());
+                NewModulePath.c_str(), EC.message().c_str());
       // Build a map of module to the GUIDs and summary objects that should
       // be written to its index.
       std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
       gatherImportedSummariesForModule(InputFile.file().name,
                                        ModuleToDefinedGVSummaries, ImportLists,
                                        ModuleToSummariesForIndex);
       WriteIndexToFile(CombinedIndex, OS, &ModuleToSummariesForIndex);
 
       if (options::thinlto_emit_imports_files) {
         if ((EC = EmitImportsFiles(
                  InputFile.file().name,
-                 (Twine(InputFile.file().name) + ".imports").str(),
+                 (Twine(NewModulePath) + ".imports").str(),
                  ImportLists)))
           message(LDPL_FATAL, "Unable to open %s.imports",
-                  InputFile.file().name, EC.message().c_str());
+                  NewModulePath.c_str(), EC.message().c_str());
       }
     }
 
     cleanup_hook();
     exit(0);
   }
 
   // Create OS in nested scope so that it will be closed on destruction.

llvm/trunk/tools/llvm-lto/llvm-lto.cpp

 #include "llvm/IRReader/IRReader.h"
 #include "llvm/LTO/LTOCodeGenerator.h"
 #include "llvm/LTO/LTOModule.h"
 #include "llvm/LTO/ThinLTOCodeGenerator.h"
 #include "llvm/Object/ModuleSummaryIndexObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 #include <list>
 
cl::values(
         clEnumValN(THINALL, "run", "Perform ThinLTO end-to-end"),
         clEnumValEnd));
 
 static cl::opt<std::string>
     ThinLTOIndex("thinlto-index",
                  cl::desc("Provide the index produced by a ThinLink, required "
                           "to perform the promotion and/or importing."));
 
+static cl::opt<std::string> ThinLTOPrefixReplace(
+    "thinlto-prefix-replace",
+    cl::desc("Control where files for distributed backends are "
+             "created. Expects 'oldprefix:newprefix' and if path "
+             "prefix of output file is oldprefix it will be "
+             "replaced with newprefix."));
+
 static cl::opt<std::string> ThinLTOModuleId(
     "thinlto-module-id",
     cl::desc("For the module ID for the file to process, useful to "
              "match what is in the index."));
 
 static cl::opt<std::string>
     ThinLTOCacheDir("thinlto-cache-dir", cl::desc("Enable ThinLTO caching."));
 
static void createCombinedModuleSummaryIndex() {
   assert(!OutputFilename.empty());
   raw_fd_ostream OS(OutputFilename + ".thinlto.bc", EC,
                     sys::fs::OpenFlags::F_None);
   error(EC, "error opening the file '" + OutputFilename + ".thinlto.bc'");
   WriteIndexToFile(CombinedIndex, OS);
   OS.close();
 }
 
+/// Parse the thinlto_prefix_replace option into the \p OldPrefix and
+/// \p NewPrefix strings, if it was specified.
+static void getThinLTOOldAndNewPrefix(std::string &OldPrefix,
+                                      std::string &NewPrefix) {
+  assert(ThinLTOPrefixReplace.empty() ||
+         ThinLTOPrefixReplace.find(":") != StringRef::npos);
+  StringRef PrefixReplace = ThinLTOPrefixReplace;
+  std::pair<StringRef, StringRef> Split = PrefixReplace.split(":");
+  OldPrefix = Split.first.str();
+  NewPrefix = Split.second.str();
+}
+
+/// Given the original \p Path to an output file, replace any path
+/// prefix matching \p OldPrefix with \p NewPrefix. Also, create the
+/// resulting directory if it does not yet exist.
+static std::string getThinLTOOutputFile(const std::string &Path,
+                                        const std::string &OldPrefix,
+                                        const std::string &NewPrefix) {
+  if (OldPrefix.empty() && NewPrefix.empty())
+    return Path;
+  SmallString<128> NewPath(Path);
+  llvm::sys::path::replace_path_prefix(NewPath, OldPrefix, NewPrefix);
+  StringRef ParentPath = llvm::sys::path::parent_path(NewPath.str());
+  if (!ParentPath.empty()) {
+    // Make sure the new directory exists, creating it if necessary.
+    if (std::error_code EC = llvm::sys::fs::create_directories(ParentPath))
+      error(EC, "error creating the directory '" + ParentPath + "'");
+  }
+  return NewPath.str();
+}
+
 namespace thinlto {
 
 std::vector<std::unique_ptr<MemoryBuffer>>
 loadAllFilesForIndex(const ModuleSummaryIndex &Index) {
   std::vector<std::unique_ptr<MemoryBuffer>> InputBuffers;
 
   for (auto &ModPath : Index.modulePaths()) {
     const auto &Filename = ModPath.first();
private:
   /// content).
   void distributedIndexes() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");
 
+    std::string OldPrefix, NewPrefix;
+    getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
+
     auto Index = loadCombinedIndex();
     for (auto &Filename : InputFilenames) {
       // Build a map of module to the GUIDs and summary objects that should
       // be written to its index.
       std::map<std::string, GVSummaryMapTy> ModuleToSummariesForIndex;
       ThinLTOCodeGenerator::gatherImportedSummariesForModule(
           Filename, *Index, ModuleToSummariesForIndex);
 
       std::string OutputName = OutputFilename;
       if (OutputName.empty()) {
         OutputName = Filename + ".thinlto.bc";
       }
+      OutputName = getThinLTOOutputFile(OutputName, OldPrefix, NewPrefix);
       std::error_code EC;
       raw_fd_ostream OS(OutputName, EC, sys::fs::OpenFlags::F_None);
       error(EC, "error opening the file '" + OutputName + "'");
       WriteIndexToFile(*Index, OS, &ModuleToSummariesForIndex);
     }
   }
 
   /// Load the combined index from disk, compute the imports, and emit
   /// the import file lists for each module to disk.
   void emitImports() {
     if (InputFilenames.size() != 1 && !OutputFilename.empty())
       report_fatal_error("Can't handle a single output filename and multiple "
                          "input files, do not provide an output filename and "
                          "the output files will be suffixed from the input "
                          "ones.");
 
+    std::string OldPrefix, NewPrefix;
+    getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
+
     auto Index = loadCombinedIndex();
     for (auto &Filename : InputFilenames) {
       std::string OutputName = OutputFilename;
       if (OutputName.empty()) {
         OutputName = Filename + ".imports";
       }
+      OutputName = getThinLTOOutputFile(OutputName, OldPrefix, NewPrefix);
       ThinLTOCodeGenerator::emitImports(Filename, OutputName, *Index);
     }
   }
 
   /// Load the combined index from disk, then load every file referenced by
   /// the index and add them to the generator, finally perform the promotion
   /// on the files mentioned on the command line (these must match the index
   /// content).

llvm/trunk/unittests/Support/Path.cpp

#else
   EXPECT_EQ("b/c", remove_dots("./a/../b/c", true));
   EXPECT_EQ("c", remove_dots("././c", true));
 
   SmallString<64> Path1("././c");
   EXPECT_TRUE(path::remove_dots(Path1, true));
   EXPECT_EQ("c", Path1);
 #endif
 }
+
+TEST(Support, ReplacePathPrefix) {
+  SmallString<64> Path1("/foo");
+  SmallString<64> Path2("/old/foo");
+  SmallString<64> OldPrefix("/old");
+  SmallString<64> NewPrefix("/new");
+  SmallString<64> NewPrefix2("/longernew");
+  SmallString<64> EmptyPrefix("");
+
+  SmallString<64> Path = Path1;
+  path::replace_path_prefix(Path, OldPrefix, NewPrefix);
+  EXPECT_EQ(Path, "/foo");
+  Path = Path2;
+  path::replace_path_prefix(Path, OldPrefix, NewPrefix);
+  EXPECT_EQ(Path, "/new/foo");
+  Path = Path2;
+  path::replace_path_prefix(Path, OldPrefix, NewPrefix2);
+  EXPECT_EQ(Path, "/longernew/foo");
+  Path = Path1;
+  path::replace_path_prefix(Path, EmptyPrefix, NewPrefix);
+  EXPECT_EQ(Path, "/new/foo");
+  Path = Path2;
+  path::replace_path_prefix(Path, OldPrefix, EmptyPrefix);
+  EXPECT_EQ(Path, "/foo");
+}
 } // anonymous namespace