llvm-ar: be more clever about default format

Try to be more clever about selecting the default format.  When an existing
archive is used, use the type of the archive to determine the format.  When
existing members are present, use the first member's format to determine the
format to use.  If we are creating an empty archive (MRI mode) or are adding
non-object members, default to the current behaviour of using the host type due
to the lack of a better alternative.  This aids in cross-compilation on Darwin
to non-Darwin platforms which rely on GNU format archives.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@273373 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/tools/llvm-ar/llvm-ar.cpp b/tools/llvm-ar/llvm-ar.cpp
index 01c8b804a73b663086e86c10adffcc2a745ba1ec..0078bda4db42033e5f9c3e1a43559d094cf8bb3a 100644 (file)
--- a/tools/llvm-ar/llvm-ar.cpp
+++ b/tools/llvm-ar/llvm-ar.cpp
@@ -19,6 +19,7 @@
 #include "llvm/LibDriver/LibDriver.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ArchiveWriter.h"
+#include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Errc.h"
@@ -575,21 +576,86 @@ computeNewArchiveMembers(ArchiveOperation Operation,
   return Ret;
 }
 
+static object::Archive::Kind getDefaultForHost() {
+  return Triple(sys::getProcessTriple()).isOSDarwin() ? object::Archive::K_BSD
+                                                      : object::Archive::K_GNU;
+}
+
+static object::Archive::Kind
+getKindFromMember(const NewArchiveIterator &Member) {
+  if (Member.isNewMember()) {
+    object::Archive::Kind Kind = getDefaultForHost();
+
+    sys::fs::file_status Status;
+    if (auto OptionalFD = Member.getFD(Status)) {
+      auto OptionalMB = MemoryBuffer::getOpenFile(*OptionalFD, Member.getName(),
+                                                  Status.getSize(), false);
+      if (OptionalMB) {
+        MemoryBufferRef MemoryBuffer = (*OptionalMB)->getMemBufferRef();
+
+        Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =
+            object::ObjectFile::createObjectFile(MemoryBuffer);
+
+        if (OptionalObject)
+          Kind = isa<object::MachOObjectFile>(**OptionalObject)
+              ? object::Archive::K_BSD
+              : object::Archive::K_GNU;
+
+        // squelch the error in case we had a non-object file
+        consumeError(OptionalObject.takeError());
+      }
+
+      if (close(*OptionalFD) != 0)
+        failIfError(std::error_code(errno, std::generic_category()),
+                    "failed to close file");
+    }
+
+    return Kind;
+  } else {
+    const object::Archive::Child &OldMember = Member.getOld();
+    if (OldMember.getParent()->isThin())
+      return object::Archive::Kind::K_GNU;
+
+    auto OptionalMB = OldMember.getMemoryBufferRef();
+    failIfError(OptionalMB.getError());
+
+    Expected<std::unique_ptr<object::ObjectFile>> OptionalObject =
+        object::ObjectFile::createObjectFile(*OptionalMB);
+
+    if (OptionalObject)
+      return isa<object::MachOObjectFile>(*OptionalObject->get())
+                 ? object::Archive::K_BSD
+                 : object::Archive::K_GNU;
+
+    // squelch the error in case we had a non-object file
+    consumeError(OptionalObject.takeError());
+    return getDefaultForHost();
+  }
+}
+
 static void
 performWriteOperation(ArchiveOperation Operation,
                       object::Archive *OldArchive,
                       std::unique_ptr<MemoryBuffer> OldArchiveBuf,
                       std::vector<NewArchiveIterator> *NewMembersP) {
+  std::vector<NewArchiveIterator> NewMembers;
+  if (!NewMembersP)
+    NewMembers = computeNewArchiveMembers(Operation, OldArchive);
+
   object::Archive::Kind Kind;
   switch (FormatOpt) {
-  case Default: {
-    Triple T(sys::getProcessTriple());
-    if (T.isOSDarwin() && !Thin)
-      Kind = object::Archive::K_BSD;
-    else
+  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();
+    else
+      Kind = NewMembers.size() ? getKindFromMember(NewMembers.front())
+                               : getDefaultForHost();
     break;
-  }
   case GNU:
     Kind = object::Archive::K_GNU;
     break;
@@ -599,18 +665,10 @@ performWriteOperation(ArchiveOperation Operation,
     Kind = object::Archive::K_BSD;
     break;
   }
-  if (NewMembersP) {
-    std::pair<StringRef, std::error_code> Result = writeArchive(
-        ArchiveName, *NewMembersP, Symtab, Kind, Deterministic, Thin,
-        std::move(OldArchiveBuf));
-    failIfError(Result.second, Result.first);
-    return;
-  }
-  std::vector<NewArchiveIterator> NewMembers =
-      computeNewArchiveMembers(Operation, OldArchive);
-  auto Result =
-      writeArchive(ArchiveName, NewMembers, Symtab, Kind, Deterministic, Thin,
-      std::move(OldArchiveBuf));
+
+  std::pair<StringRef, std::error_code> Result =
+      writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,
+                   Kind, Deterministic, Thin, std::move(OldArchiveBuf));
   failIfError(Result.second, Result.first);
 }