[llvm-ar] Add --output to specify output directory

[MaskRay]

Summary

From binutils 2.34 onwards, ar supports --output to specify a directory
where archive members should be extracted to. Port this feature.

[jhenderson]

I'm uncertain, but should we have a test case where the output directory doesn't exist?

llvm/docs/CommandGuide/llvm-ar.rst

279

llvm/test/tools/llvm-ar/extract.test

38

44

I'm not sure what "after the operation" here means?

[gbreynoo]

llvm/test/tools/llvm-ar/extract.test

51

I think it would be worth adding a test case for if the given output location does not exist.

llvm/tools/llvm-ar/llvm-ar.cpp

94

--output needs adding to the help text.

[MaskRay]

address comments

[jhenderson]

llvm/test/tools/llvm-ar/extract.test

38

I think it helps to be explicit here.

llvm/tools/llvm-ar/llvm-ar.cpp

567

Probably need a test case that the potential error is handled correctly. This should be easy to create by simply having a file where a directory is expected.

[MaskRay]

test %errc_ENOTDIR

[MaskRay]

llvm/test/tools/llvm-ar/extract.test

51

I just reuse the --output=dir case.

[MaskRay]

update comment in llvm/utils/lit/lit/llvm/config.py

[MaskRay]

use is_directory

[jhenderson]

LGTM, with one suggestion.

llvm/tools/llvm-ar/llvm-ar.cpp

472

OutputDir probably should be quoted in case there are any spaces in the path.

[MaskRay]

quote OutputDir in the diagnostic

llvm/docs/CommandGuide/llvm-ar.rst

 
  Print a summary of command-line options and their meanings.
 
 .. option:: -M
 
  This option allows for MRI scripts to be read through the standard input
  stream. No other options are compatible with this option.
 
+.. option:: --output=<dir>
+
+ Specify a directory where archive members should be extracted. By default the
+ current working directory is used.
+
 .. option:: --rsp-quoting=<type>
  This option selects the quoting style ``<type>`` for response files, either
  ``posix`` or ``windows``. The default when on Windows is ``windows``, otherwise the
  default is ``posix``.
 
 .. option:: --thin
 
  When creating or modifying an archive, this option specifies that the

llvm/test/tools/llvm-ar/absolute-paths.test

 
 xP above is only required because we were explicitly extracting items from an
 archive with absolute paths. Extracting all objects doesn't need P because we
 aren't explicitly requesting any individual object.
 RUN: rm -f a.o b.o
 RUN: llvm-ar x %S/Inputs/absolute-paths.lib
 RUN: llvm-nm a.o | FileCheck %s --check-prefix=CHECK-A
 RUN: llvm-nm b.o | FileCheck %s --check-prefix=CHECK-B
+
+RUN: mkdir dir
+RUN: llvm-ar x %S/Inputs/absolute-paths.lib --output=dir/
+RUN: cmp a.o dir/a.o

llvm/test/tools/llvm-ar/extract.test

 # RUN: not llvm-ar x %t/thin-archive.a 2>&1 | FileCheck %s --check-prefix=THIN
 # THIN: extracting from a thin archive is not supported
 
 ## No output if 'v' is not specified.
 # RUN: rm a.txt b.txt
 # RUN: llvm-ar x %t/archive.a 2>&1 | count 0
 # RUN: diff %t/a.txt %t/extracted/a.txt
 # RUN: diff %t/b.txt %t/extracted/b.txt
+
+## --output specifies the directory to extract archive members.
+# RUN: mkdir %t/extracted/dir
+# RUN: llvm-ar --output=dir x %t/archive.a
+# RUN: diff %t/a.txt %t/extracted/dir/a.txt
+# RUN: diff %t/b.txt %t/extracted/dir/b.txt
+
+## Test --output with an absolute path after the operation.
+# RUN: rm -f %t/extracted/dir/a.txt
+# RUN: llvm-ar xv %t/archive.a a.txt --output=%t/extracted/dir/../dir | FileCheck %s --check-prefix=OUTPUT-A
+# RUN: diff %t/a.txt %t/extracted/dir/a.txt
+# OUTPUT-A: x - {{.*}}extracted{{.*}}a.txt
+
+# RUN: not llvm-ar rc --output=dir %t/archive.a %t/a.txt 2>&1 | FileCheck %s --check-prefix=OUTPUT-ERR
+# OUTPUT-ERR: error: --output is only applicable to the 'x' operation

llvm/tools/llvm-ar/llvm-ar.cpp

static void printArHelp(StringRef ToolName) {
   --plugin=<string>     - ignored for compatibility
   -h --help             - display this help and exit
   --rsp-quoting         - quoting style for response files
     =posix              -   posix
     =windows            -   windows
   --thin                - create a thin archive
   --version             - print the version and exit
   @<file>               - read options from <file>
 
 OPERATIONS:
   d - delete [files] from the archive
   m - move [files] in the archive
   p - print contents of [files] found in the archive
   q - quick append [files] to the archive
   r - replace or insert [files] into the archive
   s - act as ranlib
   t - display list of files in archive

 // match for extract/delete operations when there are multiple matches. This is
 // 1-indexed. A value of 0 is invalid, and implies 'N' is not used.
 static int CountParam = 0;
 
 // This variable holds the name of the archive file as given on the
 // command line.
 static std::string ArchiveName;
 
+// Output directory specified by --output.
+static std::string OutputDir;
+
 static std::vector<std::unique_ptr<MemoryBuffer>> ArchiveBuffers;
 static std::vector<std::unique_ptr<object::Archive>> Archives;
 
 // This variable holds the list of member files to proecess, as given
 // on the command line.
 static std::vector<StringRef> Members;
 
 // Static buffer to hold StringRefs.
if (Operation != Move && Operation != ReplaceOrInsert)
       badUsage("the 'a', 'b' and 'i' modifiers can only be specified with "
                "the 'm' or 'r' operations");
   if (CountParam)
     if (Operation != Extract && Operation != Delete)
       badUsage("the 'N' modifier can only be specified with the 'x' or 'd' "
                "operations");
   if (OriginalDates && Operation != Extract)
     badUsage("the 'o' modifier is only applicable to the 'x' operation");
+  if (!OutputDir.empty() && Operation != Extract)
+    badUsage("--output is only applicable to the 'x' operation");
   if (OnlyUpdate && Operation != ReplaceOrInsert)
     badUsage("the 'u' modifier is only applicable to the 'r' operation");
   if (AddLibrary && Operation != QuickAppend)
     badUsage("the 'L' modifier is only applicable to the 'q' operation");
 
   // Return the parsed operation to the caller
   return Operation;
 }
 
 // Implements the 'p' operation. This function traverses the archive
 // looking for members that match the path list.
 static void doPrint(StringRef Name, const object::Archive::Child &C) {
   if (Verbose)
     outs() << "Printing " << Name << "\n";
 
   Expected<StringRef> DataOrErr = C.getBuffer();
   failIfError(DataOrErr.takeError());
   StringRef Data = *DataOrErr;
   outs().write(Data.data(), Data.size());
 }
 
 // Utility function for printing out the file mode when the 't' operation is in
 // verbose mode.
 static void printMode(unsigned mode) {

 // Implement the 'x' operation. This function extracts files back to the file
 // system.
 static void doExtract(StringRef Name, const object::Archive::Child &C) {
   // Retain the original mode.
   Expected<sys::fs::perms> ModeOrErr = C.getAccessMode();
   failIfError(ModeOrErr.takeError());
   sys::fs::perms Mode = ModeOrErr.get();
 
-  llvm::StringRef outputFilePath = sys::path::filename(Name);
+  StringRef outputFilePath;
+  SmallString<128> path;
+  if (OutputDir.empty()) {
+    outputFilePath = sys::path::filename(Name);
+  } else {
+    sys::path::append(path, OutputDir, sys::path::filename(Name));
+    outputFilePath = path.str();
+  }
+
   if (Verbose)
     outs() << "x - " << outputFilePath << '\n';
 
   int FD;
   failIfError(sys::fs::openFileForWrite(outputFilePath, FD,
                                         sys::fs::CD_CreateAlways,
                                         sys::fs::OF_None, Mode),
               Name);
if (Match) {
                        .Case("bsd", BSD)
                        .Case("bigarchive", BIGARCHIVE)
                        .Default(Unknown);
       if (FormatType == Unknown)
         fail(std::string("Invalid format ") + Match);
       continue;
     }
 
+    if ((Match = matchFlagWithArg("output", ArgIt, Argv))) {
+      OutputDir = Match;
+      continue;
+    }
+
     if (matchFlagWithArg("plugin", ArgIt, Argv) ||
         matchFlagWithArg("rsp-quoting", ArgIt, Argv))
       continue;
 
     Options += *ArgIt + 1;
   }
 
   ArchiveOperation Operation = parseCommandLine();