COFF: Implement /reproduce flag.

[pcc]

Summary

This flag is similar to --reproduce in the ELF linker.

This patch implements /reproduce by moving the cpio writer and associated
utility functions to lldCore, and using that implementation in both linkers.

One COFF-specific detail is that we store the object file from which the
resource files were created in our reproducer, rather than the resource
files themselves. This allows the reproducer to be used on non-Windows
systems for example.

[compnerd]

COFF/Driver.cpp

315 ↗

(On Diff #64168)

Unnecessary braces

COFF/Options.td

37 ↗

(On Diff #64168)

We should use the link flag here. /linkrepro:<directory for staging>

[ruiu]

ELF/Driver.cpp

272–273 ↗

(On Diff #64168)

check does not return if there's an error, but we want to return to the caller as it is not a critical error such as object file is corrupted.

lib/Core/Reproduce.cpp

81 ↗

(On Diff #64168)

How can it fail?

[pcc]

• Remove braces and fix merge error

COFF/Options.td

37 ↗

(On Diff #64168)

Even though this flag has different semantics to the link.exe flag?

[ruiu]

COFF/Options.td

37 ↗

(On Diff #64171)

I think I prefer not use the same option name as we always create an archive whether the link succeeded or not.

[pcc]

• Fix error handling

[pcc]

lib/Core/Reproduce.cpp

82 ↗

(On Diff #64171)

Apparently if there is an error getting the current directory.

http://llvm-cs.pcc.me.uk/lib/Support/Path.cpp#824
http://llvm-cs.pcc.me.uk/lib/Support/Unix/Path.inc#248

[ruiu]

lib/Core/Reproduce.cpp

83 ↗

(On Diff #64175)

It seems that if getcwd (or equivalent) failed, the system is really broken and can't do anything sane. Should we just swallow an error and returns the original string in case of an error?

[ruiu]

COFF/Driver.cpp

313 ↗

(On Diff #64171)

You might be able to remote Twine().

COFF/Error.h

36 ↗

(On Diff #64171)

Swap the condition (if (!EO)) for the consistency with other functions in this file.

COFF/InputFiles.cpp

99 ↗

(On Diff #64171)

Remove Twine?

ELF/Driver.cpp

273 ↗

(On Diff #64171)

Twine?

[compnerd]

COFF/Options.td

37 ↗

(On Diff #64175)

I did try this. It seems that I was mistaken and link does *always* populate the directory. If it fails really early like in the command line parsing, it will only populate link.rsp, but it does populate it. So, I think that the behaviour matches what we currently have in lld, and we should be able to use the same name.

[pcc]

• Address review comments

[pcc]

COFF/Options.td

37 ↗

(On Diff #64175)

Okay, this now uses the /linkrepro flag. We create a file named "repro.cpio" in the given directory.

lib/Core/Reproduce.cpp

83 ↗

(On Diff #64175)

Seems reasonable enough to me, done.

[ruiu]

LGTM

COFF/Driver.cpp

318 ↗

(On Diff #65456)

/linkrepro

COFF/Driver.h

73 ↗

(On Diff #65456)

for /linkrepro

lld/trunk/COFF/CMakeLists.txt

add_lld_library(lldCOFF
   LibDriver
   Object
   MC
   MCDisassembler
   Target
   Option
   Support
 
-  LINK_LIBS ${PTHREAD_LIB}
+  LINK_LIBS
+  lldCore
+  ${PTHREAD_LIB}
   )
 
 add_dependencies(lldCOFF COFFOptionsTableGen)

lld/trunk/COFF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_COFF_DRIVER_H
 #define LLD_COFF_DRIVER_H
 
 #include "Config.h"
 #include "SymbolTable.h"
 #include "lld/Core/LLVM.h"
+#include "lld/Core/Reproduce.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/StringSaver.h"
 #include <memory>
 #include <set>

 class LinkerDriver {
 public:
   LinkerDriver() : Alloc(AllocAux) {}
   void link(llvm::ArrayRef<const char *> Args);
 
   // Used by the resolver to parse .drectve section contents.
   void parseDirectives(StringRef S);
 
+  std::unique_ptr<CpioFile> Cpio; // for /linkrepro
+
 private:
   llvm::BumpPtrAllocator AllocAux;
   llvm::StringSaver Alloc;
   ArgParser Parser;
   SymbolTable Symtab;
 
   // Opens a file. Path has to be resolved already.
   MemoryBufferRef openFile(StringRef Path);

lld/trunk/COFF/Driver.cpp

MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
   std::unique_ptr<MemoryBuffer> MB =
       check(MemoryBuffer::getFile(Path), "could not open " + Path);
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take ownership
   return MBRef;
 }
 
 static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+  if (Driver->Cpio)
+    Driver->Cpio->append(relativeToRoot(MB.getBufferIdentifier()),
+                         MB.getBuffer());
+
   // File type is detected by contents, not by file extension.
   file_magic Magic = identify_magic(MB.getBuffer());
   if (Magic == file_magic::archive)
     return std::unique_ptr<InputFile>(new ArchiveFile(MB));
   if (Magic == file_magic::bitcode)
     return std::unique_ptr<InputFile>(new BitcodeFile(MB));
   if (Config->OutputFile == "")
     Config->OutputFile = getOutputPath(MB.getBufferIdentifier());

 }
 
 static uint64_t getDefaultImageBase() {
   if (Config->is64())
     return Config->DLL ? 0x180000000 : 0x140000000;
   return Config->DLL ? 0x10000000 : 0x400000;
 }
 
+static std::string createResponseFile(const llvm::opt::InputArgList &Args,
+                                      ArrayRef<MemoryBufferRef> MBs,
+                                      ArrayRef<StringRef> SearchPaths) {
+  SmallString<0> Data;
+  raw_svector_ostream OS(Data);
+
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getID()) {
+    case OPT_linkrepro:
+    case OPT_INPUT:
+    case OPT_defaultlib:
+    case OPT_libpath:
+      break;
+    default:
+      OS << stringize(Arg) << "\n";
+    }
+  }
+
+  for (StringRef Path : SearchPaths) {
+    std::string RelPath = relativeToRoot(Path);
+    OS << "/libpath:" << quote(RelPath) << "\n";
+  }
+
+  for (MemoryBufferRef MB : MBs) {
+    std::string InputPath = relativeToRoot(MB.getBufferIdentifier());
+    OS << quote(InputPath) << "\n";
+  }
+
+  return Data.str();
+}
+
 void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
   if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
     if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
       fatal("lib failed");
     return;
   }
void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
   llvm::opt::InputArgList Args = Parser.parseLINK(ArgsArr.slice(1));
 
   // Handle /help
   if (Args.hasArg(OPT_help)) {
     printHelp(ArgsArr[0]);
     return;
   }
 
+  if (auto *Arg = Args.getLastArg(OPT_linkrepro)) {
+    SmallString<64> Path = StringRef(Arg->getValue());
+    llvm::sys::path::append(Path, "repro");
+    ErrorOr<CpioFile *> F = CpioFile::create(Path);
+    if (F)
+      Cpio.reset(*F);
+    else
+      llvm::errs() << "/linkrepro: failed to open " << Path
+                   << ".cpio: " << F.getError().message() << '\n';
+  }
+
   if (Args.filtered_begin(OPT_INPUT) == Args.filtered_end())
     fatal("no input files");
 
   // Construct search path list.
   SearchPaths.push_back("");
   for (auto *Arg : Args.filtered(OPT_libpath))
     SearchPaths.push_back(Arg->getValue());
   addLibSearchPaths();
if (Config->Machine == IMAGE_FILE_MACHINE_UNKNOWN) {
     llvm::errs() << "warning: /machine is not specified. x64 is assumed.\n";
     Config->Machine = AMD64;
   }
 
   // Windows specific -- Convert Windows resource files to a COFF file.
   if (!Resources.empty()) {
     std::unique_ptr<MemoryBuffer> MB = convertResToCOFF(Resources);
     Symtab.addFile(createFile(MB->getMemBufferRef()));
+
+    MBs.push_back(MB->getMemBufferRef());
     OwningMBs.push_back(std::move(MB)); // take ownership
   }
 
+  if (Cpio)
+    Cpio->append("response.txt",
+                 createResponseFile(Args, MBs,
+                                    ArrayRef<StringRef>(SearchPaths).slice(1)));
+
   // Handle /largeaddressaware
   if (Config->is64() || Args.hasArg(OPT_largeaddressaware))
     Config->LargeAddressAware = true;
 
   // Handle /highentropyva
   if (Config->is64() && !Args.hasArg(OPT_highentropyva_no))
     Config->HighEntropyVA = true;
 

lld/trunk/COFF/Error.h

 }
 
 template <class T> T check(Expected<T> E, const Twine &Prefix) {
   if (llvm::Error Err = E.takeError())
     fatal(Err, Prefix);
   return std::move(*E);
 }
 
+template <class T> T check(ErrorOr<T> EO) {
+  if (!EO)
+    fatal(EO.getError().message());
+  return std::move(*EO);
+}
+
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Chunks.h"
 #include "Config.h"
+#include "Driver.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/LTO/legacy/LTOModule.h"

 MemoryBufferRef ArchiveFile::getMember(const Archive::Symbol *Sym) {
   const Archive::Child &C =
       check(Sym->getMember(),
             "could not get the member for symbol " + Sym->getName());
 
   // Return an empty buffer if we have already returned the same buffer.
   if (Seen[C.getChildOffset()].test_and_set())
     return MemoryBufferRef();
-  return check(C.getMemoryBufferRef(),
-               "could not get the buffer for the member defining symbol " +
-                   Sym->getName());
+
+  MemoryBufferRef MB =
+      check(C.getMemoryBufferRef(),
+  if (C.getParent()->isThin() && Driver->Cpio)
+    Driver->Cpio->append(relativeToRoot(check(C.getFullName())),
+                         MB.getBuffer());
+
+  return MB;
 }
 
 void ObjectFile::parse() {
   // Parse a memory buffer as a COFF file.
   std::unique_ptr<Binary> Bin =
       check(createBinary(MB), "failed to parse object file");
 
   if (auto *Obj = dyn_cast<COFFObjectFile>(Bin.get())) {

lld/trunk/COFF/Options.td

 def delayload : P<"delayload", "Delay loaded DLL name">;
 def entry   : P<"entry", "Name of entry point symbol">;
 def export  : P<"export", "Export a function">;
 // No help text because /failifmismatch is not intended to be used by the user.
 def failifmismatch : P<"failifmismatch", "">;
 def heap    : P<"heap", "Size of the heap">;
 def implib  : P<"implib", "Import library name">;
 def libpath : P<"libpath", "Additional library search path">;
+def linkrepro : P<"linkrepro", "Dump linker invocation and input files for debugging">;
 def machine : P<"machine", "Specify target platform">;
 def merge   : P<"merge", "Combine sections">;
 def mllvm   : P<"mllvm", "Options to pass to LLVM">;
 def nodefaultlib : P<"nodefaultlib", "Remove a default library">;
 def opt     : P<"opt", "Control optimizations">;
 def out     : P<"out", "Path to file to write output">;
 def pdb : P<"pdb", "PDB file path">;
 def section : P<"section", "Specify section attributes">;

lld/trunk/ELF/CMakeLists.txt

add_lld_library(lldELF
   Passes
   MC
   Support
   Target
   TransformUtils
 
   LINK_LIBS
   lldConfig
+  lldCore
   ${PTHREAD_LIB}
   )
 
 add_dependencies(lldELF intrinsics_gen ELFOptionsTableGen)

lld/trunk/ELF/Driver.h

 //===- Driver.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_DRIVER_H
 #define LLD_ELF_DRIVER_H
 
 #include "SymbolTable.h"
 #include "lld/Core/LLVM.h"
+#include "lld/Core/Reproduce.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf {
 
 extern class LinkerDriver *Driver;
 
-class CpioFile;
-
 class LinkerDriver {
 public:
   void main(ArrayRef<const char *> Args);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
   llvm::LLVMContext Context;      // to parse bitcode ifles
   std::unique_ptr<CpioFile> Cpio; // for reproduce
 

 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
-// This is the class to create a .cpio file for --reproduce.
-//
-// If "--reproduce foo" is given, we create a file "foo.cpio" and
-// copy all input files to the archive, along with a response file
-// to re-run the same command with the same inputs.
-// It is useful for reporting issues to LLD developers.
-//
-// Cpio as a file format is a deliberate choice. It's standardized in
-// POSIX and very easy to create. cpio command is available virtually
-// on all Unix systems. See
-// http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_07
-// for the format details.
-class CpioFile {
-public:
-  static CpioFile *create(StringRef OutputPath);
-  void append(StringRef Path, StringRef Data);
-
-private:
-  CpioFile(std::unique_ptr<llvm::raw_fd_ostream> OS, StringRef Basename);
-
-  std::unique_ptr<llvm::raw_fd_ostream> OS;
-  llvm::StringSet<> Seen;
-  std::string Basename;
-};
-
 void printHelp(const char *Argv0);
 std::string getVersionString();
 std::vector<uint8_t> parseHexstring(StringRef S);
 
 std::string createResponseFile(const llvm::opt::InputArgList &Args);
-std::string relativeToRoot(StringRef Path);
 
 std::string findFromSearchPaths(StringRef Path);
 std::string searchLibrary(StringRef Path);
 std::string buildSysrootedPath(llvm::StringRef Dir, llvm::StringRef File);
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Driver.cpp

void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
   if (Args.hasArg(OPT_version)) {
     outs() << getVersionString();
     return;
   }
 
   if (const char *Path = getReproduceOption(Args)) {
     // Note that --reproduce is a debug option so you can ignore it
     // if you are trying to understand the whole picture of the code.
-    Cpio.reset(CpioFile::create(Path));
-    if (Cpio) {
+    ErrorOr<CpioFile *> F = CpioFile::create(Path);
+    if (F) {
+      Cpio.reset(*F);
       Cpio->append("response.txt", createResponseFile(Args));
       Cpio->append("version.txt", getVersionString());
-    }
+    } else
+      error(F.getError(),
+            Twine("--reproduce: failed to open ") + Path + ".cpio");
   }
 
   readConfigs(Args);
   initLLVM(Args);
   createFiles(Args);
   checkOptions(Args);
   if (HasError)
     return;

lld/trunk/ELF/DriverUtils.cpp

 // are so many small functions, we created this separate file to make
 // Driver.cpp less cluttered.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Driver.h"
 #include "Error.h"
 #include "lld/Config/Version.h"
+#include "lld/Core/Reproduce.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/StringSaver.h"
 

 std::string elf::getVersionString() {
   std::string Version = getLLDVersion();
   std::string Repo = getLLDRepositoryVersion();
   if (Repo.empty())
     return "LLD " + Version + "\n";
   return "LLD " + Version + " " + Repo + "\n";
 }
 
-// Makes a given pathname an absolute path first, and then remove
-// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
-// assuming that the current directory is "/home/john/bar".
-std::string elf::relativeToRoot(StringRef Path) {
-  SmallString<128> Abs = Path;
-  if (std::error_code EC = fs::make_absolute(Abs))
-    fatal("make_absolute failed: " + EC.message());
-  path::remove_dots(Abs, /*remove_dot_dot=*/true);
-
-  // This is Windows specific. root_name() returns a drive letter
-  // (e.g. "c:") or a UNC name (//net). We want to keep it as part
-  // of the result.
-  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 Res.str();
-}
-
-CpioFile::CpioFile(std::unique_ptr<raw_fd_ostream> OS, StringRef S)
-    : OS(std::move(OS)), Basename(S) {}
-
-CpioFile *CpioFile::create(StringRef OutputPath) {
-  std::string Path = (OutputPath + ".cpio").str();
-  std::error_code EC;
-  auto OS = llvm::make_unique<raw_fd_ostream>(Path, EC, fs::F_None);
-  if (EC) {
-    error(EC, "--reproduce: failed to open " + Path);
-    return nullptr;
-  }
-  return new CpioFile(std::move(OS), path::filename(OutputPath));
-}
-
-static void writeMember(raw_fd_ostream &OS, StringRef Path, StringRef Data) {
-  // The c_dev/c_ino pair should be unique according to the spec,
-  // but no one seems to care.
-  OS << "070707";                        // c_magic
-  OS << "000000";                        // c_dev
-  OS << "000000";                        // c_ino
-  OS << "100664";                        // c_mode: C_ISREG | rw-rw-r--
-  OS << "000000";                        // c_uid
-  OS << "000000";                        // c_gid
-  OS << "000001";                        // c_nlink
-  OS << "000000";                        // c_rdev
-  OS << "00000000000";                   // c_mtime
-  OS << format("%06o", Path.size() + 1); // c_namesize
-  OS << format("%011o", Data.size());    // c_filesize
-  OS << Path << '\0';                    // c_name
-  OS << Data;                            // c_filedata
-}
-
-void CpioFile::append(StringRef Path, StringRef Data) {
-  if (!Seen.insert(Path).second)
-    return;
-
-  // Construct an in-archive filename so that /home/foo/bar is stored
-  // as baz/home/foo/bar where baz is the basename of the output file.
-  // (i.e. in that case we are creating baz.cpio.)
-  SmallString<128> Fullpath;
-  path::append(Fullpath, Basename, Path);
-
-  // Use unix path separators so the cpio can be extracted on both unix and
-  // windows.
-  std::replace(Fullpath.begin(), Fullpath.end(), '\\', '/');
-
-  writeMember(*OS, Fullpath, Data);
-
-  // Print the trailer and seek back.
-  // This way we have a valid archive if we crash.
-  uint64_t Pos = OS->tell();
-  writeMember(*OS, "TRAILER!!!", "");
-  OS->seek(Pos);
-}
-
-// Quote a given string if it contains a space character.
-static std::string quote(StringRef S) {
-  if (S.find(' ') == StringRef::npos)
-    return S;
-  return ("\"" + S + "\"").str();
-}
-
-static std::string rewritePath(StringRef S) {
-  if (fs::exists(S))
-    return relativeToRoot(S);
-  return S;
-}
-
-static std::string stringize(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;
-}
-
 // Reconstructs command line arguments so that so that you can re-run
 // the same command with the same inputs. This is for --reproduce.
 std::string elf::createResponseFile(const opt::InputArgList &Args) {
   SmallString<0> Data;
   raw_svector_ostream OS(Data);
 
   // Copy the command line to the output while rewriting paths.
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_reproduce:
       break;
     case OPT_INPUT:
       OS << quote(rewritePath(Arg->getValue())) << "\n";
       break;
     case OPT_L:
     case OPT_dynamic_list:
     case OPT_rpath:
     case OPT_alias_script_T:
     case OPT_script:
     case OPT_version_script:
-      OS << Arg->getSpelling() << " "
-         << quote(rewritePath(Arg->getValue())) << "\n";
+      OS << Arg->getSpelling() << " " << quote(rewritePath(Arg->getValue()))
+         << "\n";
       break;
     default:
       OS << stringize(Arg) << "\n";
     }
   }
   return Data.str();
 }
 

lld/trunk/ELF/InputFiles.h

 #define LLD_ELF_INPUT_FILES_H
 
 #include "Config.h"
 #include "InputSection.h"
 #include "Error.h"
 #include "Symbols.h"
 
 #include "lld/Core/LLVM.h"
+#include "lld/Core/Reproduce.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Support/StringSaver.h"
 

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

+//===- Reproduce.h - Utilities for creating reproducers ---------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_CORE_REPRODUCE_H
+#define LLD_CORE_REPRODUCE_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Error.h"
+
+namespace llvm {
+
+class raw_fd_ostream;
+
+namespace opt { class Arg; }
+
+}
+
+namespace lld {
+
+// This class creates a .cpio file for --reproduce (ELF) or /linkrepro (COFF).
+//
+// If "--reproduce foo" is given, we create a file "foo.cpio" and
+// copy all input files to the archive, along with a response file
+// to re-run the same command with the same inputs.
+// It is useful for reporting issues to LLD developers.
+//
+// Cpio as a file format is a deliberate choice. It's standardized in
+// POSIX and very easy to create. cpio command is available virtually
+// on all Unix systems. See
+// http://pubs.opengroup.org/onlinepubs/9699919799/utilities/pax.html#tag_20_92_13_07
+// for the format details.
+class CpioFile {
+public:
+  static ErrorOr<CpioFile *> create(StringRef OutputPath);
+  void append(StringRef Path, StringRef Data);
+
+private:
+  CpioFile(std::unique_ptr<llvm::raw_fd_ostream> OS, StringRef Basename);
+
+  std::unique_ptr<llvm::raw_fd_ostream> OS;
+  llvm::StringSet<> Seen;
+  std::string Basename;
+};
+
+// Makes a given pathname an absolute path first, and then remove
+// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
+// assuming that the current directory is "/home/john/bar".
+std::string relativeToRoot(StringRef Path);
+
+// Quote a given string if it contains a space character.
+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 stringize(llvm::opt::Arg *Arg);
+
+}
+
+#endif

lld/trunk/lib/Core/CMakeLists.txt

 add_lld_library(lldCore
   DefinedAtom.cpp
   Error.cpp
   File.cpp
   LinkingContext.cpp
   Reader.cpp
+  Reproduce.cpp
   Resolver.cpp
   SymbolTable.cpp
   Writer.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Core
 
   LINK_LIBS
     LLVMSupport
   )

lld/trunk/lib/Core/Reproduce.cpp

+//===- Reproduce.cpp - Utilities for creating reproducers -----------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Core/Reproduce.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Option/Arg.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/Path.h"
+
+using namespace lld;
+using namespace llvm;
+using namespace sys;
+
+CpioFile::CpioFile(std::unique_ptr<raw_fd_ostream> OS, StringRef S)
+    : OS(std::move(OS)), Basename(S) {}
+
+ErrorOr<CpioFile *> CpioFile::create(StringRef OutputPath) {
+  std::string Path = (OutputPath + ".cpio").str();
+  std::error_code EC;
+  auto OS = make_unique<raw_fd_ostream>(Path, EC, sys::fs::F_None);
+  if (EC)
+    return EC;
+  return new CpioFile(std::move(OS), path::filename(OutputPath));
+}
+
+static void writeMember(raw_fd_ostream &OS, StringRef Path, StringRef Data) {
+  // The c_dev/c_ino pair should be unique according to the spec,
+  // but no one seems to care.
+  OS << "070707";                        // c_magic
+  OS << "000000";                        // c_dev
+  OS << "000000";                        // c_ino
+  OS << "100664";                        // c_mode: C_ISREG | rw-rw-r--
+  OS << "000000";                        // c_uid
+  OS << "000000";                        // c_gid
+  OS << "000001";                        // c_nlink
+  OS << "000000";                        // c_rdev
+  OS << "00000000000";                   // c_mtime
+  OS << format("%06o", Path.size() + 1); // c_namesize
+  OS << format("%011o", Data.size());    // c_filesize
+  OS << Path << '\0';                    // c_name
+  OS << Data;                            // c_filedata
+}
+
+void CpioFile::append(StringRef Path, StringRef Data) {
+  if (!Seen.insert(Path).second)
+    return;
+
+  // Construct an in-archive filename so that /home/foo/bar is stored
+  // as baz/home/foo/bar where baz is the basename of the output file.
+  // (i.e. in that case we are creating baz.cpio.)
+  SmallString<128> Fullpath;
+  path::append(Fullpath, Basename, Path);
+
+  // Use unix path separators so the cpio can be extracted on both unix and
+  // windows.
+  std::replace(Fullpath.begin(), Fullpath.end(), '\\', '/');
+
+  writeMember(*OS, Fullpath, Data);
+
+  // Print the trailer and seek back.
+  // This way we have a valid archive if we crash.
+  uint64_t Pos = OS->tell();
+  writeMember(*OS, "TRAILER!!!", "");
+  OS->seek(Pos);
+}
+
+// Makes a given pathname an absolute path first, and then remove
+// beginning /. For example, "../foo.o" is converted to "home/john/foo.o",
+// assuming that the current directory is "/home/john/bar".
+std::string lld::relativeToRoot(StringRef Path) {
+  SmallString<128> Abs = Path;
+  if (sys::fs::make_absolute(Abs))
+    return Path;
+  path::remove_dots(Abs, /*remove_dot_dot=*/true);
+
+  // This is Windows specific. root_name() returns a drive letter
+  // (e.g. "c:") or a UNC name (//net). We want to keep it as part
+  // of the result.
+  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 Res.str();
+}
+
+// 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::stringize(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;
+}

lld/trunk/test/COFF/linkrepro.test

+# RUN: rm -rf %t.dir
+# RUN: mkdir -p %t.dir/build1 %t.dir/build2 %t.dir/build3
+# RUN: yaml2obj < %p/Inputs/hello32.yaml > %t.obj
+
+# RUN: cd %t.dir/build1
+# RUN: lld-link %t.obj %p/Inputs/std32.lib /subsystem:console \
+# RUN:   /entry:main@0 /linkrepro:. /out:%t.exe
+# RUN: cpio -id < repro.cpio
+# RUN: diff %t.obj repro/%:t.obj
+# RUN: diff %p/Inputs/std32.lib repro/%:p/Inputs/std32.lib
+# RUN: FileCheck %s --check-prefix=RSP < repro/response.txt
+
+# RUN: cd %t.dir/build2
+# RUN: lld-link %t.obj /libpath:%p/Inputs /defaultlib:std32 /subsystem:console \
+# RUN:   /entry:main@0 /linkrepro:. /out:%t.exe
+# RUN: cpio -id < repro.cpio
+# RUN: diff %t.obj repro/%:t.obj
+# RUN: diff %p/Inputs/std32.lib repro/%:p/Inputs/std32.lib
+# RUN: FileCheck %s --check-prefix=RSP < repro/response.txt
+
+# RUN: cd %t.dir/build3
+# RUN: env LIB=%p/Inputs lld-link %t.obj /defaultlib:std32 /subsystem:console \
+# RUN:   /entry:main@0 /linkrepro:. /out:%t.exe
+# RUN: cpio -id < repro.cpio
+# RUN: diff %t.obj repro/%:t.obj
+# RUN: diff %p/Inputs/std32.lib repro/%:p/Inputs/std32.lib
+# RUN: FileCheck %s --check-prefix=RSP < repro/response.txt
+
+# RSP: /subsystem:console
+# RSP: /entry:main@0
+# RSP-NOT: /linkrepro:
+# RSP: /out:
+# RSP: linkrepro.test.tmp.obj
+# RSP-NOT: defaultlib
+# RSP: std32.lib