[llvm-ar] Support multiple dashed options

[thomasanderson]

Summary

This allows syntax like:
$ llvm-ar -c -r -u file.a file.o

This is in addition to the other formats that are already supported:
$ llvm-ar cru file.a file.o
$ llvm-ar -cru file.a file.o

[thomasanderson]

pcc,thakis ptal

[thomasanderson]

pinging pcc (thakis is OOO)

[pcc]

Did you consider writing a custom parser as was mentioned on the bug? It really seems like it would make the code better rather than going through these contortions to fit the parsing into llvm::cl.

tools/llvm-ar/llvm-ar.cpp

965–966

Note that GNU allows more than one.

[pcc]

tools/llvm-ar/llvm-ar.cpp

106

It would be a shame to lose this usage information.

[thomasanderson]

tools/llvm-ar/llvm-ar.cpp

106

It's still there. llvm-ar --help now looks like this:
OVERVIEW: LLVM Archiver (llvm-ar)

This program archives bitcode files into single libraries

USAGE: llvm-ar [options] [relpos] [count] <archive-file> [members]...

OPTIONS:

General options:

-M                                - 
-aarch64-neon-syntax              - Choose style of NEON code to emit from AArch64 backend:
  =generic                        -   Emit generic NEON assembly
  =apple                          -   Emit Apple-style NEON assembly
-arm-add-build-attributes         - 
-arm-implicit-it                  - Allow conditional instructions outdside of an IT block
  =always                         -   Accept in both ISAs, emit implicit ITs in Thumb
  =never                          -   Warn in ARM, reject in Thumb
  =arm                            -   Accept in ARM, reject in Thumb
  =thumb                          -   Warn in ARM, emit implicit ITs in Thumb
-enable-packed-inlinable-literals - Enable packed inlinable literals (v2f16, v2i16)
-format                           - Archive format to create
  =default                        -   default
  =gnu                            -   gnu
  =darwin                         -   darwin
  =bsd                            -   bsd
-gpsize=<uint>                    - Global Pointer Addressing Size.  The default size is 8.
-merror-missing-parenthesis       - Error for missing parenthesis around predicate registers
-merror-noncontigious-register    - Error for register names that aren't contigious
-mhvx                             - Enable Hexagon Vector eXtensions
  =v60                            -   Build for HVX v60
  =v62                            -   Build for HVX v62
  =v65                            -   Build for HVX v65
  =                               -   
-mno-compound                     - Disable looking for compound instructions for Hexagon
-mno-fixup                        - Disable fixing up resolved relocations for Hexagon
-mno-pairing                      - Disable looking for duplex instructions for Hexagon
-mwarn-missing-parenthesis        - Warn for missing parenthesis around predicate registers
-mwarn-noncontigious-register     - Warn for register names that arent contigious
-mwarn-sign-mismatch              - Warn for mismatching a signed and unsigned value
-plugin=<string>                  - plugin (ignored for compatibility)
-print-module-scope               - When printing IR for print-[before|after]{-all} always print a module IR

Generic Options:

-help                             - Display available options (-help-hidden for more)
-help-list                        - Display list of available options (-help-list-hidden for more)
-version                          - Display the version of this program

Modifiers (generic):

-c                                - do not warn if the library had to be created
-v                                - be verbose about actions taken

Modifiers (operation specific):

-S                                - do not build a symbol table
-T                                - create a thin archive
-a                                - put file(s) after [relpos]
-b                                - put file(s) before [relpos] (same as [i])
-i                                - put file(s) before [relpos] (same as [b])
-o                                - preserve original dates
-s                                - create an archive index (cf. ranlib)
-u                                - update only files newer than archive contents

Operations:

-d                                - delete file(s) from the archive
-m                                - move file(s) in the archive
-p                                - print file(s) found in the archive
-q                                - append file(s) to the archive
-r                                - replace or insert file(s) into the archive
-t                                - display contents of archive
-x                                - extract file(s) from the archive

Unless you mean the [NsS] on "d" etc. We could add that back in the description if you want.

965–966

Ack

[thomasanderson]

In D44452#1045304, @pcc wrote:

Did you consider writing a custom parser as was mentioned on the bug? It really seems like it would make the code better rather than going through these contortions to fit the parsing into llvm::cl.

Yeah, but there's still a lot of general options

-M -
-aarch64-neon-syntax - Choose style of NEON code to emit from AArch64 backend:

=generic                        -   Emit generic NEON assembly
=apple                          -   Emit Apple-style NEON assembly

-arm-add-build-attributes -
-arm-implicit-it - Allow conditional instructions outdside of an IT block

=always                         -   Accept in both ISAs, emit implicit ITs in Thumb
=never                          -   Warn in ARM, reject in Thumb
=arm                            -   Accept in ARM, reject in Thumb
=thumb                          -   Warn in ARM, emit implicit ITs in Thumb

-enable-packed-inlinable-literals - Enable packed inlinable literals (v2f16, v2i16)
-format - Archive format to create

=default                        -   default
=gnu                            -   gnu
=darwin                         -   darwin
=bsd                            -   bsd

-gpsize=<uint> - Global Pointer Addressing Size. The default size is 8.
-merror-missing-parenthesis - Error for missing parenthesis around predicate registers
-merror-noncontigious-register - Error for register names that aren't contigious
-mhvx - Enable Hexagon Vector eXtensions

=v60                            -   Build for HVX v60
=v62                            -   Build for HVX v62
=v65                            -   Build for HVX v65
=                               -

-mno-compound - Disable looking for compound instructions for Hexagon
-mno-fixup - Disable fixing up resolved relocations for Hexagon
-mno-pairing - Disable looking for duplex instructions for Hexagon
-mwarn-missing-parenthesis - Warn for missing parenthesis around predicate registers
-mwarn-noncontigious-register - Warn for register names that arent contigious
-mwarn-sign-mismatch - Warn for mismatching a signed and unsigned value
-plugin=<string> - plugin (ignored for compatibility)
-print-module-scope - When printing IR for print-[before|after]{-all} always print a module IR

I feel like it's easier just to use llvm::cl directly.

[pcc]

Yeah, but there's still a lot of general options

Most of those options are irrelevant to llvm-ar and should not appear in its help output. The ones that we care about are --format, -M and --plugin, and we can easily parse them ourselves.

[thomasanderson]

In D44452#1045867, @pcc wrote:

Yeah, but there's still a lot of general options

Most of those options are irrelevant to llvm-ar and should not appear in its help output. The ones that we care about are --format, -M and --plugin, and we can easily parse them ourselves.

Ah, that's a good point. If you think it's worth it, I can give the custom parser a try

[pcc]

In D44452#1045873, @thomasanderson wrote:

In D44452#1045867, @pcc wrote:

Yeah, but there's still a lot of general options

Most of those options are irrelevant to llvm-ar and should not appear in its help output. The ones that we care about are --format, -M and --plugin, and we can easily parse them ourselves.

Ah, that's a good point. If you think it's worth it, I can give the custom parser a try

Please do, at least so that we have a point of comparison.

[thomasanderson]

In D44452#1045877, @pcc wrote:

In D44452#1045873, @thomasanderson wrote:

In D44452#1045867, @pcc wrote:

Yeah, but there's still a lot of general options

Most of those options are irrelevant to llvm-ar and should not appear in its help output. The ones that we care about are --format, -M and --plugin, and we can easily parse them ourselves.

Ah, that's a good point. If you think it's worth it, I can give the custom parser a try

Please do, at least so that we have a point of comparison.

Done in latest revision

[thomasanderson]

Don't land this yet, I'm getting some errors when building Chromium

[pcc]

tools/llvm-ar/llvm-ar.cpp

64

I would lose the "Gener*ptions" headers (here and below), they aren't really providing much information.

867

No else after return

898

No else after return

899

It seems like you should be able to add the remaining arguments to PositionalArgs and break out of the loop, that way the rest of the code doesn't need to worry about it.

910

Move the parsing of the format type here and use a StringSwitch.

919

It seems that the correct check here is Options.empty().

[thomasanderson]

Chrome builds now -- it was an issue with not handling response files

[pcc]

Looking mostly good.

tools/llvm-ar/llvm-ar.cpp

888

No else after return.

931

It looks like this needs to happen before parsing the arguments.

971–972

If you move this if statement above line 967, we can remove the check for ranlib from that line.

[pcc]

LGTM with a few nits. Thanks for working on this.

tools/llvm-ar/llvm-ar.cpp

876

Can you initialize this vector like this: SmallVector<const char *, 0> Argv(argv, argv + argc);

884

Is this possible?

[thomasanderson]

Also you'll have to land this for me, since I don't have write permissions in the repo

[pcc]

It looks like the following tests started failing with your change:

LLVM :: Object/archive-GNU64-write.test
LLVM :: Object/mri5.test

Can you please take a look?

[thomasanderson]

In D44452#1048772, @pcc wrote:

It looks like the following tests started failing with your change:

LLVM :: Object/archive-GNU64-write.test
LLVM :: Object/mri5.test

Can you please take a look?

Sure, looking now

[thomasanderson]

Fixed test failures

[pcc]

lib/Object/ArchiveWriter.cpp

456

This parameter was intentionally not exposed by the writeArchive interface because it is for testing purposes only. Probably the easiest thing to do to keep it that way would be to arrange to pass it using an environment variable.

[thomasanderson]

Use environment variable for Object/archive-GNU64-write.test

[pcc]

r328716

Thanks!

[thakis]

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

55 ↗

(On Diff #140099)

This includes a newline at the start of the string, which makes the -help output look a bit weird.

[thomasanderson]

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

55 ↗

(On Diff #140099)

D'oh!

IMO the cleanest way to do this is to replace
const char RanlibHelp[] = R"(
with
const char *RanlibHelp = 1 + R"(

It would be a bit superfluous for me to upload a new CL to fix this considering someone with write permissions in the repo would have to land it for me.

lib/Object/ArchiveWriter.cpp

 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 using namespace llvm;
 
-// The SYM64 format is used when an archive's member offsets are larger than
-// 32-bits can hold. The need for this shift in format is detected by
-// writeArchive. To test this we need to generate a file with a member that has
-// an offset larger than 32-bits but this demands a very slow test. To speed
-// the test up we use this flag to pretend like the cutoff happens before
-// 32-bits and instead happens at some much smaller value.
-static cl::opt<int> Sym64Threshold("sym64-threshold", cl::Hidden,
-                                   cl::init(32));
-
 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef)
     : Buf(MemoryBuffer::getMemBuffer(BufRef, false)),
       MemberName(BufRef.getBufferIdentifier()) {}
 
 Expected<NewArchiveMember>
 NewArchiveMember::getOldMember(const object::Archive::Child &OldMember,
                                bool Deterministic) {
   Expected<llvm::MemoryBufferRef> BufOrErr = OldMember.getMemoryBufferRef();
computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames,
   return Ret;
 }
 
 Error llvm::writeArchive(StringRef ArcName,
                          ArrayRef<NewArchiveMember> NewMembers,
                          bool WriteSymtab, object::Archive::Kind Kind,
                          bool Deterministic, bool Thin,
                          std::unique_ptr<MemoryBuffer> OldArchiveBuf) {
   assert((!Thin || !isBSDLike(Kind)) && "Only the gnu format has a thin mode");
 
   SmallString<0> SymNamesBuf;
   raw_svector_ostream SymNames(SymNamesBuf);
   SmallString<0> StringTableBuf;
   raw_svector_ostream StringTable(StringTableBuf);
 
   Expected<std::vector<MemberData>> DataOrErr =
       computeMemberData(StringTable, SymNames, Kind, Thin, ArcName, NewMembers);
if (WriteSymtab) {
     for (const auto& M : Data) {
       // Record the start of the member's offset
       LastOffset = MaxOffset;
       // Account for the size of each part associated with the member.
       MaxOffset += M.Header.size() + M.Data.size() + M.Padding.size();
       // We assume 32-bit symbols to see if 32-bit symbols are possible or not.
       MaxOffset += M.Symbols.size() * 4;
     }
+
+    // The SYM64 format is used when an archive's member offsets are larger than
+    // 32-bits can hold. The need for this shift in format is detected by
+    // writeArchive. To test this we need to generate a file with a member that
+    // has an offset larger than 32-bits but this demands a very slow test. To
+    // speed the test up we use this environment variable to pretend like the
+    // cutoff happens before 32-bits and instead happens at some much smaller
+    // value.
+    const char *Sym64Env = std::getenv("SYM64_THRESHOLD");
+    int Sym64Threshold = 32;
+    if (Sym64Env)
+      StringRef(Sym64Env).getAsInteger(10, Sym64Threshold);
+
     // If LastOffset isn't going to fit in a 32-bit varible we need to switch
     // to 64-bit. Note that the file can be larger than 4GB as long as the last
     // member starts before the 4GB offset.
     if (LastOffset >= (1ULL << Sym64Threshold))
       Kind = object::Archive::K_GNU64;
   }
 
   Expected<sys::fs::TempFile> Temp =

test/Object/archive-GNU64-write.test

 # REQUIRES: llvm-64-bits
 # REQUIRES: system-linux
 
 # RUN: yaml2obj %s > %t
 # RUN: dd if=%t of=%t bs=1 count=0 seek=1M
 # RUN: rm -f %t.lib
 # RUN: cp %t %t2
-# RUN: llvm-ar -sym64-threshold=19 cr %t.lib %t %t2 %p/Inputs/trivial-object-test.elf-x86-64
+# RUN: SYM64_THRESHOLD=19 llvm-ar cr %t.lib %t %t2 %p/Inputs/trivial-object-test.elf-x86-64
 # RUN: llvm-nm --print-armap %t.lib | FileCheck %s
 # RUN: grep SYM64 %t.lib
 
 # Delete temp files. They are too large.
 # RUN: rm -f %t %t2 %t.lib
 
 !ELF
 FileHeader:

test/tools/llvm-ar/default-add.test

 RUN: yaml2obj %S/Inputs/macho.yaml -o %t-macho.o
 RUN: yaml2obj %S/Inputs/coff.yaml -o %t-coff.o
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t-macho.o
 RUN: grep -q __.SYMDEF %t.ar
 Test that an option string prefixed by a dash works.
 RUN: llvm-ar -crs %t.ar %t-coff.o
 RUN: grep -q __.SYMDEF %t.ar
 
 RUN: rm -f %t.ar
 RUN: llvm-ar crs %t.ar %t-coff.o
 RUN: not grep -q __.SYMDEF %t.ar
 RUN: llvm-ar crs %t.ar %t-macho.o
 RUN: not grep -q __.SYMDEF %t.ar
 
+RUN: rm -f %t.ar
+Test that multiple dashed options works.
+RUN: llvm-ar -c -r -s %t.ar %t-macho.o
+RUN: grep -q __.SYMDEF %t.ar
+Test with duplicated options.
+RUN: llvm-ar -c -r -s -c -s %t.ar %t-coff.o
+RUN: grep -q __.SYMDEF %t.ar
+
+RUN: rm -f %t.ar
+Test with the options in a different order.
+RUN: llvm-ar rsc %t.ar %t-macho.o
+RUN: grep -q __.SYMDEF %t.ar
+Test with options everywhere.
+RUN: llvm-ar rsc -cs -sc %t.ar %t-coff.o -cs -sc
+RUN: grep -q __.SYMDEF %t.ar
+
 Ensure that we select the existing format when updating.
 

tools/llvm-ar/llvm-ar.cpp

 #include "llvm/Support/Format.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Support/StringSaver.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 using namespace llvm;
 
 // The name this program was invoked as.
 static StringRef ToolName;
 
+// The basename of this program.
+static StringRef Stem;
+
+const char RanlibHelp[] = R"(
+OVERVIEW: LLVM Ranlib (llvm-ranlib)
+
+  This program generates an index to speed access to archives
+
+USAGE: llvm-ranlib <archive-file>
+
+OPTIONS:
+  -help                             - Display available options
+  -version                          - Display the version of this program
+)";
+
+const char ArHelp[] = R"(
+OVERVIEW: LLVM Archiver (llvm-ar)
+
+  This program archives bitcode files into single libraries
+
+USAGE: llvm-ar [options] [relpos] [count] <archive-file> [members]...
+
+OPTIONS:
+  -M                                -
+  -format                           - Archive format to create
+    =default                        -   default
+    =gnu                            -   gnu
+    =darwin                         -   darwin
+    =bsd                            -   bsd
+  -plugin=<string>                  - plugin (ignored for compatibility
+  -help                             - Display available options
+  -version                          - Display the version of this program
+
+OPERATIONS:
+  d[NsS]       - delete file(s) from the archive
+  m[abiSs]     - move file(s) in the archive
+  p[kN]        - print file(s) found in the archive
+  q[ufsS]      - quick append file(s) to the archive
+  r[abfiuRsS]  - replace or insert file(s) into the archive
+  t            - display contents of archive
+  x[No]        - extract file(s) from the archive
+
+MODIFIERS (operation specific):
+  [a] - put file(s) after [relpos]
+  [b] - put file(s) before [relpos] (same as [i])
+  [D] - use zero for timestamps and uids/gids (default)
+  [i] - put file(s) before [relpos] (same as [b])
+  [o] - preserve original dates
+  [s] - create an archive index (cf. ranlib)
+  [S] - do not build a symbol table
+  [T] - create a thin archive
+  [u] - update only files newer than archive contents
+  [U] - use actual timestamps and uids/gids
+
+MODIFIERS (generic):
+  [c] - do not warn if the library had to be created
+  [v] - be verbose about actions taken
+)";
+
+void printHelpMessage() {
+  if (Stem.find("ranlib") != StringRef::npos)
+    outs() << RanlibHelp;
+  else if (Stem.find("ar") != StringRef::npos)
+    outs() << ArHelp;
+}
+
 // Show the error message and exit.
 LLVM_ATTRIBUTE_NORETURN static void fail(Twine Error) {
   errs() << ToolName << ": " << Error << ".\n";
-  cl::PrintHelpMessage();
+  printHelpMessage();
   exit(1);
 }
 
 static void failIfError(std::error_code EC, Twine Context = "") {
   if (!EC)
     return;
 
   std::string ContextStr = Context.str();
static void failIfError(Error E, Twine Context = "") {
   handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) {
     std::string ContextStr = Context.str();
     if (ContextStr == "")
       fail(EIB.message());
     fail(Context + ": " + EIB.message());
   });
 }
 
-// llvm-ar/llvm-ranlib remaining positional arguments.
-static cl::list<std::string>
-    RestOfArgs(cl::Positional, cl::ZeroOrMore,
-               cl::desc("[relpos] [count] <archive-file> [members]..."));
+SmallVector<const char *, 256> PositionalArgs;
 
-static cl::opt<bool> MRI("M", cl::desc(""));
-static cl::opt<std::string> Plugin("plugin", cl::desc("plugin (ignored for compatibility"));
+static bool MRI;
 
 namespace {
-enum Format { Default, GNU, BSD, DARWIN };
+enum Format { Default, GNU, BSD, DARWIN, Unknown };
 }
 
-static cl::opt<Format>
-    FormatOpt("format", cl::desc("Archive format to create"),
-              cl::values(clEnumValN(Default, "default", "default"),
-                         clEnumValN(GNU, "gnu", "gnu"),
-                         clEnumValN(DARWIN, "darwin", "darwin"),
-                         clEnumValN(BSD, "bsd", "bsd")));
+static Format FormatType = Default;
 
 static std::string Options;
 
-// Provide additional help output explaining the operations and modifiers of
-// llvm-ar. This object instructs the CommandLine library to print the text of
-// the constructor when the --help option is given.
-static cl::extrahelp MoreHelp(
-  "\nOPERATIONS:\n"
-  "  d[NsS]       - delete file(s) from the archive\n"
-  "  m[abiSs]     - move file(s) in the archive\n"
-  "  p[kN]        - print file(s) found in the archive\n"
-  "  q[ufsS]      - quick append file(s) to the archive\n"
-  "  r[abfiuRsS]  - replace or insert file(s) into the archive\n"
-  "  t            - display contents of archive\n"
-  "  x[No]        - extract file(s) from the archive\n"
-  "\nMODIFIERS (operation specific):\n"
-  "  [a] - put file(s) after [relpos]\n"
-  "  [b] - put file(s) before [relpos] (same as [i])\n"
-  "  [i] - put file(s) before [relpos] (same as [b])\n"
-  "  [o] - preserve original dates\n"
-  "  [s] - create an archive index (cf. ranlib)\n"
-  "  [S] - do not build a symbol table\n"
-  "  [T] - create a thin archive\n"
-  "  [u] - update only files newer than archive contents\n"
-  "\nMODIFIERS (generic):\n"
-  "  [c] - do not warn if the library had to be created\n"
-  "  [v] - be verbose about actions taken\n"
-);
-
-static const char OptionChars[] = "dmpqrtxabiosSTucv";
-
 // This enumeration delineates the kinds of operations on an archive
 // that are permitted.
 enum ArchiveOperation {
   Print,            ///< Print the contents of the archive
   Delete,           ///< Delete the specified members
   Move,             ///< Move members to end or as given by {a,b,i} modifiers
   QuickAppend,      ///< Quickly append to end of archive
   ReplaceOrInsert,  ///< Replace or Insert members

 
 // This variable holds the list of member files to proecess, as given
 // on the command line.
 static std::vector<StringRef> Members;
 
 // Extract the member filename from the command line for the [relpos] argument
 // associated with a, b, and i modifiers
 static void getRelPos() {
-  if(RestOfArgs.size() == 0)
+  if (PositionalArgs.size() == 0)
     fail("Expected [relpos] for a, b, or i modifier");
-  RelPos = RestOfArgs[0];
-  RestOfArgs.erase(RestOfArgs.begin());
-}
-
-static void getOptions() {
-  if(RestOfArgs.size() == 0)
-    fail("Expected options");
-  Options = RestOfArgs[0];
-  RestOfArgs.erase(RestOfArgs.begin());
+  RelPos = PositionalArgs[0];
+  PositionalArgs.erase(PositionalArgs.begin());
 }
 
 // Get the archive file name from the command line
 static void getArchive() {
-  if(RestOfArgs.size() == 0)
+  if (PositionalArgs.size() == 0)
     fail("An archive name must be specified");
-  ArchiveName = RestOfArgs[0];
-  RestOfArgs.erase(RestOfArgs.begin());
+  ArchiveName = PositionalArgs[0];
+  PositionalArgs.erase(PositionalArgs.begin());
 }
 
-// Copy over remaining items in RestOfArgs to our Members vector
+// Copy over remaining items in PositionalArgs to our Members vector
 static void getMembers() {
-  for (auto &Arg : RestOfArgs)
+  for (auto &Arg : PositionalArgs)
     Members.push_back(Arg);
 }
 
 static void runMRIScript();
 
 // Parse the command line options as presented and return the operation
 // specified. Process all modifiers and check to make sure that constraints on
 // modifier/operation pairs have not been violated.
 static ArchiveOperation parseCommandLine() {
   if (MRI) {
-    if (!RestOfArgs.empty())
+    if (!PositionalArgs.empty() || !Options.empty())
       fail("Cannot mix -M and other options");
     runMRIScript();
   }
 
-  getOptions();
-
   // Keep track of number of operations. We can only specify one
   // per execution.
   unsigned NumOperations = 0;
 
   // Keep track of the number of positional modifiers (a,b,i). Only
   // one can be specified.
   unsigned NumPositional = 0;
 
performWriteOperation(ArchiveOperation Operation,
                       object::Archive *OldArchive,
                       std::unique_ptr<MemoryBuffer> OldArchiveBuf,
                       std::vector<NewArchiveMember> *NewMembersP) {
   std::vector<NewArchiveMember> NewMembers;
   if (!NewMembersP)
     NewMembers = computeNewArchiveMembers(Operation, OldArchive);
 
   object::Archive::Kind Kind;
-  switch (FormatOpt) {
+  switch (FormatType) {
   case Default:
     if (Thin)
       Kind = object::Archive::K_GNU;
     else if (OldArchive)
       Kind = OldArchive->kind();
     else if (NewMembersP)
       Kind = NewMembersP->size() ? getKindFromMember(NewMembersP->front())
                                  : getDefaultForHost();
if (Thin)
       fail("Only the gnu format has a thin mode");
     Kind = object::Archive::K_BSD;
     break;
   case DARWIN:
     if (Thin)
       fail("Only the gnu format has a thin mode");
     Kind = object::Archive::K_DARWIN;
     break;
+  case Unknown:
+    llvm_unreachable("");
   }
 
   Error E =
       writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,
                    Kind, Deterministic, Thin, std::move(OldArchiveBuf));
   failIfError(std::move(E), ArchiveName);
 }
 
static void runMRIScript() {
   }
 
   // Nothing to do if not saved.
   if (Saved)
     performOperation(ReplaceOrInsert, &NewMembers);
   exit(0);
 }
 
-static int ar_main() {
-  // Do our own parsing of the command line because the CommandLine utility
-  // can't handle the grouped positional parameters without a dash.
+static bool handleGenericOption(StringRef arg) {
+  if (arg == "-help" || arg == "--help") {
+    printHelpMessage();
+    return true;
+  }
+  if (arg == "-version" || arg == "--version") {
+    cl::PrintVersionMessage();
+    return true;
+  }
+  return false;
+}
+
+static int ar_main(int argc, char **argv) {
+  SmallVector<const char *, 0> Argv(argv, argv + argc);
+  BumpPtrAllocator Alloc;
+  StringSaver Saver(Alloc);
+  cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv);
+  for(size_t i = 1; i < Argv.size(); ++i) {
+    StringRef Arg = Argv[i];
+    const char *match;
+    auto MatchFlagWithArg = [&](const char *expected) {
+      size_t len = strlen(expected);
+      if (Arg == expected) {
+        if (++i >= Argv.size())
+          fail(std::string(expected) + " requires an argument");
+        match = Argv[i];
+        return true;
+      }
+      if (Arg.startswith(expected) && Arg.size() > len &&
+                 Arg[len] == '=') {
+        match = Arg.data() + len + 1;
+        return true;
+      }
+      return false;
+    };
+    if (handleGenericOption(Argv[i]))
+      return 0;
+    if (Arg == "--") {
+      for(; i < Argv.size(); ++i)
+        PositionalArgs.push_back(Argv[i]);
+      break;
+    }
+    if (Arg[0] == '-') {
+      if (Arg.startswith("--"))
+        Arg = Argv[i] + 2;
+      else
+        Arg = Argv[i] + 1;
+      if (Arg == "M") {
+        MRI = true;
+      } else if (MatchFlagWithArg("format")) {
+        FormatType = StringSwitch<Format>(match)
+            .Case("default", Default)
+            .Case("gnu", GNU)
+            .Case("darwin", DARWIN)
+            .Case("bsd", BSD)
+            .Default(Unknown);
+        if (FormatType == Unknown)
+          fail(std::string("Invalid format ") + match);
+      } else if (MatchFlagWithArg("plugin")) {
+        // Ignored.
+      } else {
+        Options += Argv[i] + 1;
+      }
+    } else if (Options.empty()) {
+      Options += Argv[i];
+    } else {
+      PositionalArgs.push_back(Argv[i]);
+    }
+  }
   ArchiveOperation Operation = parseCommandLine();
   return performOperation(Operation, nullptr);
 }
 
-static int ranlib_main() {
-  if (RestOfArgs.size() != 1)
-    fail(ToolName + " takes just one archive as an argument");
-  ArchiveName = RestOfArgs[0];
+static int ranlib_main(int argc, char **argv) {
+  bool ArchiveSpecified = false;
+  for(int i = 1; i < argc; ++i) {
+    if (handleGenericOption(argv[i])) {
+      return 0;
+    } else {
+      if (ArchiveSpecified)
+        fail("Exactly one archive should be specified");
+      ArchiveSpecified = true;
+      ArchiveName = argv[i];
+    }
+  }
   return performOperation(CreateSymTab, nullptr);
 }
 
 int main(int argc, char **argv) {
   ToolName = argv[0];
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
-  StringRef Stem = sys::path::stem(ToolName);
+  Stem = sys::path::stem(ToolName);
   if (Stem.find("dlltool") != StringRef::npos)
     return dlltoolDriverMain(makeArrayRef(argv, argc));
 
-  if (Stem.find("ranlib") == StringRef::npos &&
-      Stem.find("lib") != StringRef::npos)
-    return libDriverMain(makeArrayRef(argv, argc));
-
-  SmallVector<const char *, 256> Argv;
-  SpecificBumpPtrAllocator<char> ArgAllocator;
-  failIfError(errorCodeToError(sys::Process::GetArgumentVector(
-      Argv, makeArrayRef(argv, argc), ArgAllocator)));
-
-  for (unsigned i = 1; i < Argv.size(); i++) {
-    // If an argument starts with a dash and only contains chars
-    // that belong to the options chars set, remove the dash.
-    // We can't handle it after the command line options parsing
-    // is done, since it will error out on an unrecognized string
-    // starting with a dash.
-    // Make sure this doesn't match the actual llvm-ar specific options
-    // that start with a dash.
-    StringRef S = Argv[i];
-    if (S.startswith("-") &&
-        S.find_first_not_of(OptionChars, 1) == StringRef::npos) {
-      Argv[i]++;
-      break;
-    }
-    if (S == "--")
-      break;
-  }
+  if (Stem.find("ranlib") != StringRef::npos)
+    return ranlib_main(argc, argv);
 
-  // Have the command line options parsed and handle things
-  // like --help and --version.
-  cl::ParseCommandLineOptions(Argv.size(), Argv.data(),
-    "LLVM Archiver (llvm-ar)\n\n"
-    "  This program archives bitcode files into single libraries\n"
-  );
+  if (Stem.find("lib") != StringRef::npos)
+    return libDriverMain(makeArrayRef(argv, argc));
 
-  if (Stem.find("ranlib") != StringRef::npos)
-    return ranlib_main();
   if (Stem.find("ar") != StringRef::npos)
-    return ar_main();
+    return ar_main(argc, argv);
   fail("Not ranlib, ar, lib or dlltool!");
 }