[llvm-lib] Use COFF archive format in llvm-lib (other archive tools don't use this format).

[jacek]

Summary

We currently just use GNU format for llvm-lib. This mostly works, but ARM64EC needs an additional section that does not really fit GNU format. This patch implements writing in COFF format (as in, it's what archive reader considers as K_COFF). This mostly requires symbol emitting symbol map. Note that, just like in case of MSVC, symbols are de-duplicated in both usual symbol table and the new symbol map.

[mstorsjo]

So - I'm not very familiar with the internals of static archives, can you elaborate a bit more on what K_COFF vs K_GNU means here. Is this a format flag which is written to the static archives themselves (I believe not?), or just different conventions for what details are written and found in the archives? Currently, when reading such archives, are they identified as K_GNU or K_COFF? And currently, before this patch, which mode is used? If I read the patch correctly (I just eyed it quickly) - llvm-ar will continue to write things like it used to, while llvm-lib will pick K_COFF (unless it's a thin library)?

[mstorsjo]

llvm/test/tools/llvm-lib/duplicate.test

20

Before this change, would --print-armap not have printed anything at all, or what's the change in externally visible functionality here?

[jacek]

In D143540#4113923, @mstorsjo wrote:

So - I'm not very familiar with the internals of static archives, can you elaborate a bit more on what K_COFF vs K_GNU means here. Is this a format flag which is written to the static archives themselves (I believe not?), or just different conventions for what details are written and found in the archives?

It's about how details are written to the archives, the meaning in this patch it analogical to how reader uses them, see Archive class constructor. Essentially, if the second member is another symbol table, then the archive treated as K_COFF. The other subtle difference is that strings in string table are null-terminated, see ArchiveMemberHeader::getName. This patch makes it possible to write archives that will be recognized as K_COFF.

Currently, when reading such archives, are they identified as K_GNU or K_COFF? And currently, before this patch, which mode is used?

Libraries generated by current llvm-lib are identified as K_GNU. Libraries generated by llvm-lib with this patch are identified as K_COFF.

If I read the patch correctly (I just eyed it quickly) - llvm-ar will continue to write things like it used to, while llvm-lib will pick K_COFF (unless it's a thin library)?

Yes, nothing changes for llvm-ar yet. I guess it would make sense to add new llvm-ar --format argument for that, but we probably shouldn't change the default. If we changed the default for Windows host, it would require explicit --format when cross compiling from Windows, which is currently not required.

[jacek]

llvm/test/tools/llvm-lib/duplicate.test

20

Without this patch, it would print duplicated and unsorted symbols:

Archive map
b in bar.o
c in abc.o
a in abc.o
b in abc.o
a in foo.o

[mstorsjo]

In D143540#4114098, @jacek wrote:

In D143540#4113923, @mstorsjo wrote:

So - I'm not very familiar with the internals of static archives, can you elaborate a bit more on what K_COFF vs K_GNU means here. Is this a format flag which is written to the static archives themselves (I believe not?), or just different conventions for what details are written and found in the archives?

It's about how details are written to the archives, the meaning in this patch it analogical to how reader uses them, see Archive class constructor. Essentially, if the second member is another symbol table, then the archive treated as K_COFF. The other subtle difference is that strings in string table are null-terminated, see ArchiveMemberHeader::getName. This patch makes it possible to write archives that will be recognized as K_COFF.

Ok, thanks for the explanation! (So far in my endeavours, I've diven into most of the internals of PE/COFF, but never had to worry about the details of static archives.)

If I read the patch correctly (I just eyed it quickly) - llvm-ar will continue to write things like it used to, while llvm-lib will pick K_COFF (unless it's a thin library)?

Yes, nothing changes for llvm-ar yet. I guess it would make sense to add new llvm-ar --format argument for that, but we probably shouldn't change the default. If we changed the default for Windows host, it would require explicit --format when cross compiling from Windows, which is currently not required.

Yeah we shouldn't make such differences based on the host where the tool is running. There's some predecent for autodetecting the mode based on other context (preexisting archive or archive members, or maybe also objects passed on the command line), which mostly should avoid the cross compilation issues. See https://github.com/llvm/llvm-project/commit/a0d42c86dbcb150c2a7a3d8f2a8500dcfb98a5d1 for the original implementation of that (I believe it has evolved a bit still through the years since).

llvm/test/tools/llvm-lib/duplicate.test

20

I see, thanks!

[jacek]

rebased

[jacek]

In D143540#4114719, @mstorsjo wrote:

Yeah we shouldn't make such differences based on the host where the tool is running. There's some predecent for autodetecting the mode based on other context (preexisting archive or archive members, or maybe also objects passed on the command line), which mostly should avoid the cross compilation issues. See https://github.com/llvm/llvm-project/commit/a0d42c86dbcb150c2a7a3d8f2a8500dcfb98a5d1 for the original implementation of that (I believe it has evolved a bit still through the years since).

Interesting. Actually, that change was broken around K_COFF handling. If you try to modify an archive recognized as K_COFF, it would hit llvm_unreachable in isBSDLike when trying to write an archive. I verified that it's fixed by this patch series and llvm-ar writes K_COFF archive.

[jacek]

rebased

[efriedma]

Please explicitly note in the commit message that this doesn't affect other archive-writing tools, like llvm-ar.

Otherwise LGTM

llvm/lib/Object/ArchiveWriter.cpp

769

I'm curious, what does MSVC lib do here? Refuse to construct the archive? Skip creating the symbol table? Use some other output format?

[jacek]

llvm/lib/Object/ArchiveWriter.cpp

769

According to my testing, it has a limit of 4090 object files. When I try to pass more, I get an ambiguous error:
$ lib -out:test.lib -nologo @inputs/files.txt
LINK : fatal error LNK1104: cannot open file 'inputs\a4091.obj'

[efriedma]

llvm/lib/Object/ArchiveWriter.cpp

769

That's strange... maybe accidentally running into the C library's file handle limit. What happens if you try adding additional files to a library that already contains 4090 object files?

[jacek]

llvm/lib/Object/ArchiveWriter.cpp

769

Oh, right, I can get larger libraries this way. I can get up to 65535 object files by merging multiple libraries until I get an error:

LINK : fatal error LNK1189: library limit of 65535 objects exceeded

[efriedma]

llvm/lib/Object/ArchiveWriter.cpp

769

I guess we don't need to worry about that for compatibility, then.

llvm/lib/Object/ArchiveWriter.cpp

 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/COFF.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/EndianStream.h"

 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 using namespace llvm;
 
+struct SymMap {
+  std::map<std::string, uint16_t> Map;
+};
+
 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef)
     : Buf(MemoryBuffer::getMemBuffer(BufRef, false)),
       MemberName(BufRef.getBufferIdentifier()) {}
 
 object::Archive::Kind NewArchiveMember::detectKindFromObject() const {
   auto MemBufferRef = this->Buf->getMemBufferRef();
   Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =
       object::ObjectFile::createObjectFile(MemBufferRef);
static bool isDarwin(object::Archive::Kind Kind) {
   return Kind == object::Archive::K_DARWIN ||
          Kind == object::Archive::K_DARWIN64;
 }
 
 static bool isAIXBigArchive(object::Archive::Kind Kind) {
   return Kind == object::Archive::K_AIXBIG;
 }
 
+static bool isCOFFArchive(object::Archive::Kind Kind) {
+  return Kind == object::Archive::K_COFF;
+}
+
 static bool isBSDLike(object::Archive::Kind Kind) {
   switch (Kind) {
   case object::Archive::K_GNU:
   case object::Archive::K_GNU64:
   case object::Archive::K_AIXBIG:
+  case object::Archive::K_COFF:
     return false;
   case object::Archive::K_BSD:
   case object::Archive::K_DARWIN:
   case object::Archive::K_DARWIN64:
     return true;
-  case object::Archive::K_COFF:
-    break;
   }
   llvm_unreachable("not supported for writting");
 }
 
 template <class T>
 static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val) {
   support::endian::write(Out, Val,
                          isBSDLike(Kind) ? support::little : support::big);
 }
 
+template <class T> static void printLE(raw_ostream &Out, T Val) {
+  support::endian::write(Out, Val, support::little);
+}
+
 static void printRestOfMemberHeader(
     raw_ostream &Out, const sys::TimePoint<std::chrono::seconds> &ModTime,
     unsigned UID, unsigned GID, unsigned Perms, uint64_t Size) {
   printWithSpacePadding(Out, sys::toTimeT(ModTime), 12);
 
   // The format has only 6 chars for uid and gid. Truncate if the provided
   // values don't fit.
   printWithSpacePadding(Out, UID % 1000000, 6);
printMemberHeader(raw_ostream &Out, uint64_t Pos, raw_ostream &StringTable,
   uint64_t NamePos;
   if (Thin) {
     NamePos = StringTable.tell();
     StringTable << M.MemberName << "/\n";
   } else {
     auto Insertion = MemberNames.insert({M.MemberName, uint64_t(0)});
     if (Insertion.second) {
       Insertion.first->second = StringTable.tell();
-      StringTable << M.MemberName << "/\n";
+      StringTable << M.MemberName;
+      if (isCOFFArchive(Kind))
+        StringTable << '\0';
+      else
+        StringTable << "/\n";
     }
     NamePos = Insertion.first->second;
   }
   printWithSpacePadding(Out, NamePos, 15);
   printRestOfMemberHeader(Out, ModTime, M.UID, M.GID, M.Perms, Size);
 }
 
 namespace {
static uint64_t computeSymbolTableSize(object::Archive::Kind Kind,
   // least 4-byte aligned for 32-bit content.  Opt for the larger encoding
   // uniformly.
   // We do this for all bsd formats because it simplifies aligning members.
   // For the big archive format, the symbol table is the last member, so there
   // is no need to align.
   uint32_t Pad = isAIXBigArchive(Kind)
                      ? 0
                      : offsetToAlignment(Size, Align(isBSDLike(Kind) ? 8 : 2));
+
+  Size += Pad;
+  if (Padding)
+    *Padding = Pad;
+  return Size;
+}
+
+static uint64_t computeSymbolMapSize(uint64_t NumObj, SymMap &SymMap,
+                                     uint32_t *Padding = nullptr) {
+  uint64_t Size = sizeof(uint32_t) * 2; // Number of symbols and objects entries
+  Size += NumObj * sizeof(uint32_t);    // Offset table
+
+  for (auto S : SymMap.Map)
+    Size += sizeof(uint16_t) + S.first.length() + 1;
+
+  uint32_t Pad = offsetToAlignment(Size, Align(2));
   Size += Pad;
   if (Padding)
     *Padding = Pad;
   return Size;
 }
 
 static void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind,
                                    bool Deterministic, uint64_t Size,
                                    uint64_t PrevMemberOffset = 0) {
   if (isBSDLike(Kind)) {
     const char *Name = is64BitKind(Kind) ? "__.SYMDEF_64" : "__.SYMDEF";
     printBSDMemberHeader(Out, Out.tell(), Name, now(Deterministic), 0, 0, 0,
                          Size);
   } else if (isAIXBigArchive(Kind)) {
     printBigArchiveMemberHeader(Out, "", now(Deterministic), 0, 0,
                                 0, Size, PrevMemberOffset, 0);
   } else {
     const char *Name = is64BitKind(Kind) ? "/SYM64" : "";
     printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size);
   }
 }
 
 static uint64_t computeHeadersSize(object::Archive::Kind Kind,
+                                   uint64_t NumMembers,
                                    uint64_t StringMemberSize, uint64_t NumSyms,
-                                   uint64_t SymNamesSize) {
+                                   uint64_t SymNamesSize, SymMap *SymMap) {
   uint32_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
   uint64_t SymtabSize =
       computeSymbolTableSize(Kind, NumSyms, OffsetSize, SymNamesSize);
   auto computeSymbolTableHeaderSize = [=] {
     SmallString<0> TmpBuf;
     raw_svector_ostream Tmp(TmpBuf);
     writeSymbolTableHeader(Tmp, Kind, true, SymtabSize);
     return TmpBuf.size();
   };
+  uint32_t HeaderSize = computeSymbolTableHeaderSize();
+  uint64_t Size = strlen("!<arch>\n") + HeaderSize + SymtabSize;
+
+  if (SymMap)
+    Size += HeaderSize + computeSymbolMapSize(NumMembers, *SymMap);
 
-  return strlen("!<arch>\n") + computeSymbolTableHeaderSize() + SymtabSize + StringMemberSize;
+  return Size + StringMemberSize;
 }
 
 static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
                              bool Deterministic, ArrayRef<MemberData> Members,
                              StringRef StringTable, uint64_t MembersOffset,
                              uint64_t PrevMemberOffset = 0) {
   // We don't write a symbol table on an archive with no members -- except on
   // Darwin, where the linker will abort unless the archive has a symbol table.
-  if (StringTable.empty() && !isDarwin(Kind))
+  if (StringTable.empty() && !isDarwin(Kind) && !isCOFFArchive(Kind))
     return;
 
   unsigned NumSyms = 0;
   for (const MemberData &M : Members)
     NumSyms += M.Symbols.size();
 
   uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
   uint32_t Pad;
if (isBSDLike(Kind))
     // byte count of the string table
     printNBits(Out, Kind, StringTable.size());
   Out << StringTable;
 
   while (Pad--)
     Out.write(uint8_t(0));
 }
 
+static void writeSymbolMap(raw_ostream &Out, object::Archive::Kind Kind,
+                           bool Deterministic, ArrayRef<MemberData> Members,
+                           SymMap &SymMap, uint64_t MembersOffset) {
+  uint32_t Pad;
+  uint64_t Size = computeSymbolMapSize(Members.size(), SymMap, &Pad);
+  writeSymbolTableHeader(Out, Kind, Deterministic, Size, 0);
+
+  uint32_t Pos = MembersOffset;
+
+  printLE<uint32_t>(Out, Members.size());
+  for (const MemberData &M : Members) {
+    printLE(Out, Pos); // member offset
+    Pos += M.Header.size() + M.Data.size() + M.Padding.size();
+  }
+
+  printLE<uint32_t>(Out, SymMap.Map.size());
+
+  for (auto S : SymMap.Map)
+    printLE(Out, S.second);
+  for (auto S : SymMap.Map)
+    Out << S.first << '\0';
+
+  while (Pad--)
+    Out.write(uint8_t(0));
+}
+
 static Expected<std::vector<unsigned>>
-getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) {
+getSymbols(MemoryBufferRef Buf, uint16_t Index, raw_ostream &SymNames,
+           SymMap *SymMap, bool &HasObject) {
   std::vector<unsigned> Ret;
 
   // In the scenario when LLVMContext is populated SymbolicFile will contain a
   // reference to it, thus SymbolicFile should be destroyed first.
   LLVMContext Context;
   std::unique_ptr<object::SymbolicFile> Obj;
 
   const file_magic Type = identify_magic(Buf.getBuffer());
if (!ObjOrErr)
       return ObjOrErr.takeError();
     Obj = std::move(*ObjOrErr);
   }
 
   HasObject = true;
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))
       continue;
+    if (SymMap) {
+      std::string Name;
+      raw_string_ostream NameStream(Name);
+      if (Error E = S.printName(NameStream))
+        return std::move(E);
+      if (SymMap->Map.find(Name) != SymMap->Map.end())
+        continue; // ignore duplicated symbol
+      SymMap->Map[Name] = Index;
+      Ret.push_back(SymNames.tell());
+      SymNames << Name << '\0';
+    } else {
       Ret.push_back(SymNames.tell());
       if (Error E = S.printName(SymNames))
         return std::move(E);
       SymNames << '\0';
     }
+  }
   return Ret;
 }
 
 static Expected<std::vector<MemberData>>
 computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames,
                   object::Archive::Kind Kind, bool Thin, bool Deterministic,
-                  bool NeedSymbols, ArrayRef<NewArchiveMember> NewMembers) {
+                  bool NeedSymbols, SymMap *SymMap,
+                  ArrayRef<NewArchiveMember> NewMembers) {
   static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'};
 
   uint64_t Pos =
       isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 0;
 
   std::vector<MemberData> Ret;
   bool HasObject = false;
 
if (UniqueTimestamps) {
     for (const NewArchiveMember &M : NewMembers)
       FilenameCount[M.MemberName]++;
     for (auto &Entry : FilenameCount)
       Entry.second = Entry.second > 1 ? 1 : 0;
   }
 
   // The big archive format needs to know the offset of the previous member
   // header.
-  unsigned PrevOffset = 0;
+  unsigned PrevOffset = 0, Index = 0;
   for (const NewArchiveMember &M : NewMembers) {
     std::string Header;
     raw_string_ostream Out(Header);
 
     MemoryBufferRef Buf = M.Buf->getMemBufferRef();
     StringRef Data = Thin ? "" : Buf.getBuffer();
 
+    Index++;
+
     // ld64 expects the members to be 8-byte aligned for 64-bit content and at
     // least 4-byte aligned for 32-bit content.  Opt for the larger encoding
     // uniformly.  This matches the behaviour with cctools and ensures that ld64
     // is happy with archives that we generate.
     unsigned MemberPadding =
         isDarwin(Kind) ? offsetToAlignment(Data.size(), Align(8)) : 0;
     unsigned TailPadding =
         offsetToAlignment(Data.size() + MemberPadding, Align(2));
if (isAIXBigArchive(Kind)) {
       printMemberHeader(Out, Pos, StringTable, MemberNames, Kind, Thin, M,
                         ModTime, Size);
     }
     Out.flush();
 
     std::vector<unsigned> Symbols;
     if (NeedSymbols) {
       Expected<std::vector<unsigned>> SymbolsOrErr =
-          getSymbols(Buf, SymNames, HasObject);
+          getSymbols(Buf, Index, SymNames, SymMap, HasObject);
       if (!SymbolsOrErr)
         return createFileError(M.MemberName, SymbolsOrErr.takeError());
       Symbols = std::move(*SymbolsOrErr);
     }
 
     Pos += Header.size() + Data.size() + Padding.size();
     Ret.push_back({std::move(Symbols), std::move(Header), Data, Padding});
   }
   // If there are no symbols, emit an empty symbol table, to satisfy Solaris
   // tools, older versions of which expect a symbol table in a non-empty
   // archive, regardless of whether there are any symbols in it.
-  if (HasObject && SymNames.tell() == 0)
+  if (HasObject && SymNames.tell() == 0 && !isCOFFArchive(Kind))
     SymNames << '\0' << '\0' << '\0';
   return Ret;
 }
 
 namespace llvm {
 
 static ErrorOr<SmallString<128>> canonicalizePath(StringRef P) {
   SmallString<128> Ret = P;
static Error writeArchiveToStream(raw_ostream &Out,
                                   bool WriteSymtab, object::Archive::Kind Kind,
                                   bool Deterministic, bool Thin) {
   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);
+  SymMap SymMap;
 
-  Expected<std::vector<MemberData>> DataOrErr =
-      computeMemberData(StringTable, SymNames, Kind, Thin, Deterministic,
-                        WriteSymtab, NewMembers);
+  // COFF symbol map uses 16-bit indexes, so we can't use it if there are too
+  // many members.
+  if (isCOFFArchive(Kind) && NewMembers.size() > 0xfffe)
+    Kind = object::Archive::K_GNU;
+
+  Expected<std::vector<MemberData>> DataOrErr = computeMemberData(
+      StringTable, SymNames, Kind, Thin, Deterministic, WriteSymtab,
+      isCOFFArchive(Kind) ? &SymMap : nullptr, NewMembers);
   if (Error E = DataOrErr.takeError())
     return E;
   std::vector<MemberData> &Data = *DataOrErr;
 
   uint64_t StringTableSize = 0;
   MemberData StringTableMember;
   if (!StringTableBuf.empty() && !isAIXBigArchive(Kind)) {
     StringTableMember = computeStringTable(StringTableBuf);
static Error writeArchiveToStream(raw_ostream &Out,
   }
 
   Optional<uint64_t> HeadersSize;
 
   // The symbol table is put at the end of the big archive file. The symbol
   // table is at the start of the archive file for other archive formats.
   if (WriteSymtab && !is64BitKind(Kind)) {
     // We assume 32-bit offsets to see if 32-bit symbols are possible or not.
-    HeadersSize =
-        computeHeadersSize(Kind, StringTableSize, NumSyms, SymNamesBuf.size());
+    HeadersSize = computeHeadersSize(Kind, Data.size(), StringTableSize,
+                                     NumSyms, SymNamesBuf.size(),
+                                     isCOFFArchive(Kind) ? &SymMap : nullptr);
 
     // 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.
static Error writeArchiveToStream(raw_ostream &Out,
   else if (isAIXBigArchive(Kind))
     Out << "<bigaf>\n";
   else
     Out << "!<arch>\n";
 
   if (!isAIXBigArchive(Kind)) {
     if (WriteSymtab) {
       if (!HeadersSize)
-        HeadersSize = computeHeadersSize(Kind, StringTableSize, NumSyms,
-                                         SymNamesBuf.size());
+        HeadersSize = computeHeadersSize(
+            Kind, Data.size(), StringTableSize, NumSyms, SymNamesBuf.size(),
+            isCOFFArchive(Kind) ? &SymMap : nullptr);
       writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf,
                        *HeadersSize);
+
+      if (isCOFFArchive(Kind))
+        writeSymbolMap(Out, Kind, Deterministic, Data, SymMap, *HeadersSize);
     }
 
     if (StringTableSize)
       Out << StringTableMember.Header << StringTableMember.Data
           << StringTableMember.Padding;
 
     for (const MemberData &M : Data)
       Out << M.Header << M.Data << M.Padding;

llvm/lib/ToolDrivers/llvm-lib/LibDriver.cpp

if (sys::path::is_relative(Member.MemberName)) {
       if (PathOrErr)
         Member.MemberName = Saver.save(*PathOrErr);
     }
   }
 
   // For compatibility with MSVC, reverse member vector after de-duplication.
   std::reverse(Members.begin(), Members.end());
 
+  bool Thin = Args.hasArg(OPT_llvmlibthin);
   if (Error E =
           writeArchive(OutputPath, Members,
-                       /*WriteSymtab=*/true, object::Archive::K_GNU,
-                       /*Deterministic*/ true, Args.hasArg(OPT_llvmlibthin))) {
+                       /*WriteSymtab=*/true,
+                       Thin ? object::Archive::K_GNU : object::Archive::K_COFF,
+                       /*Deterministic*/ true, Thin)) {
     handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
       llvm::errs() << OutputPath << ": " << EI.message() << "\n";
     });
     return 1;
   }
 
   return 0;
 }

llvm/test/tools/llvm-lib/duplicate.test

 If the same file is specified more than once as an input file,
 llvm-lib should ignore all but the first occurrence of the file.
 
 RUN: rm -rf %t
 RUN: mkdir -p %t
 
 RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t/foo.o %S/Inputs/a.s
 RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t/bar.o %S/Inputs/b.s
 RUN: llvm-mc -triple=x86_64-pc-windows-msvc -filetype=obj -o %t/abc.o %S/Inputs/abc.s
 RUN: llvm-lib -out:%t/foo.lib %t/foo.o %t/foo.o %t/abc.o %t/bar.o  %t/foo.o %t/foo.o
 
 RUN: llvm-ar t %t/foo.lib | FileCheck %s
 CHECK: bar.o
 CHECK-NEXT: abc.o
 CHECK-NEXT: foo.o
 CHECK-NOT: foo.o
+
+# Check that symbol map contains sorted, de-duplicated symbols.
+RUN: cd %t && llvm-lib -out:foo.lib foo.o foo.o abc.o bar.o  foo.o foo.o
+RUN: llvm-nm --print-armap %t/foo.lib | FileCheck %s --check-prefix=DUP
+# DUP: Archive map
+# DUP-NEXT: a in abc.o
+# DUP-NEXT: b in bar.o
+# DUP-NEXT: c in abc.o
+# DUP-EMPTY