[AIX] support write operation of big archive.

[DiggerLin]

Summary

1. Enable supporting the write operation of big archive.
2. the first commit come from https://reviews.llvm.org/D104367
3. refactor the first commit and implement writing symbol table.
4. fixed the bugs and add more test cases in the second commit.

[DiggerLin]

1. refactor the first commit
2. implement write symbol table for the big archive.
3. fixed bugs and added more test cases

[jhenderson]

Just FYI, I've got a few urgent pieces of work to do, which will mean reviewing may be a bit slow. I'll try to get to this later this week, but no guarantee.

[DiggerLin]

In D123949#3458422, @jhenderson wrote:

Just FYI, I've got a few urgent pieces of work to do, which will mean reviewing may be a bit slow. I'll try to get to this later this week, but no guarantee.

Thanks for let me know, no worry, thanks a lot.

[jhenderson]

Could you link to the spec again for Big Archive, so I can try to check the code against it, please?

llvm/lib/Object/ArchiveWriter.cpp

42

Do you need this? The rest of the code in this file managed fine without it.

203–206

I'm not sure this comment adds much. Could you explain why you feel the need for it?

220

printBSDMemberHeader uses Out.write(uint8_t(0)); to write the padding. I'd probably do the same here for consistency.

llvm/test/tools/llvm-ar/bigarchive.test

3 ↗

(On Diff #423423)

4 ↗

(On Diff #423423)

As noted below, grep is deprecated in lit tests. Use FileCheck instead.

llvm/test/tools/llvm-ar/default-aix-host.test

2 ↗

(On Diff #423423)

4 ↗

(On Diff #423423)

You're not using the stderr or stdout.

5 ↗

(On Diff #423423)

As noted below, grep is deprecated in tests. Use FileCheck instead.

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

1

7

8

grep shouldn't be used in llvm lit tests (see https://llvm.org/docs/TestingGuide.html#writing-new-regression-tests). You should use FileCheck --input-file=%t.ar instead, with a check pattern as typical.

llvm/test/tools/llvm-ar/thin-to-full-archive.test

1 ↗

(On Diff #423423)

Might be worth a comment saying why it is unsupported here.

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

964–965

Do you need this sort of check for the Big format too?

[jhenderson]

llvm/lib/Object/ArchiveWriter.cpp

210–211

222

printRestOfMemberHeader just writes the terminator directly to the stream. Since no padding is needed for it, I think that's what you should do here too.

344

And reflow the comment to 80 characters.

350

And similar for the same variable elsewhere. I think this more clearly indicates what the variable is for.

356

I don't think you need to declare the name as a separate variable. Just use the string literal directly at the call site.

366–367

Do you actually need PreOffset to be passed in here? This function calculates the Pos variable below already, and the PreOffset value could be calculated as part of this.

645–659

Previously, the scope of these two variables was quite limited. Now that it is used in a wider range of code, I'd recommend renaming them to clarify which offsets they're referring to. I think it should be LastMemberHeaderOffset and LastMemberEndOffset or something to that effect. Is that right?

657

662

I think think you need to modify this call? This code is already guarded by !isAIXBigArchive(Kind).

669

Any particular reason you've added this blank line?

683

Given that this piece of code isn't hit by Big Archive anyway, this comment probably doesn't belong here?

707

You've used "Big Archive" here but "Big archive" elsewhere. Which is the correct format? Is the name of the format "Big" or "Big Archive"? If the former, then you should use "Big archive" everywhere, including here. Otherwise, you should use "Big Archive" everywhere.

708

Member Table shouldn't be capitalized as it's not a proper noun.

709

710–711

int is a signed type, which doesn't make sense for offsets.
Don't call things arrays when they aren't.

712

Could you avoid the need to loop through all members twice (i.e. above where MaxOffset and LastOffset are calculated, and here), by moving the first loop inside the first half of the if above (like it was before), and then calculating equivalent values as you go below?

713

it -> Index or I. it is not correct capitalization and could be confused with an iterator, which this isn't.

713–725

Let's reorganise this loop a little, as I find it a little hard to follow.

Is there an off-by-one error here? The MembeTableNameStrTblSize increases by the name length plus a null terminator, but the offset only increases by the name length (possibly with a padding byte, but not always). If that's the case, I'd suggest adding the following line:

size_t NameSize = Member.MemberName.size() + 1;

and then using it in place of the name length lookups.

731

This comment looks to be in the wrong place? I think it needs to be at the start of the following printWithSpacePadding block that actually writes it.

747

755

Same below.

762

767

769

770

This isn't "All names" though. This is just the current name.

Also, why not do:

Out << MemberName << '\0';

774–776

I don't think you need to say that there must be one or two trailing null characters.

[DiggerLin]

Could you link to the spec again for Big Archive, so I can try to check the code against it, please?

https://www.ibm.com/docs/en/aix/7.2?topic=formats-ar-file-format-big

[DiggerLin]

address comment

llvm/lib/Object/ArchiveWriter.cpp

42

for example. in the code ,there is several place has code like.
isAIXBigArchive(Kind) ? sizeof(BigArchive::FixLenHdr) : Out.tell() + Size;

203–206

sorry that I just keep it as the original first commit, I will delete the comment.

220

thanks

356

thanks

366–367

the calculate of pos happened after the writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset);

645–659

I am not sure whether "LastMemberHeaderOffset"(LastMemberEndOffset) is good variable name or not. for the gnu archive, it also include Symbol table. but for big archive , MaxOffset/LastOffset only include the file members(not include the Member table and global symbol table).

662

yes, good catch. thanks

712

for the gnu archive, all members include symbol table, but the big aix archive , it do not have symbol table.

713–725

thanks for simplifying the code. The name in the member file header do not have a null terminator, but the name in the string table has the null terminator.

[jhenderson]

It looks like in the latest diff you've reinstated some XFAIL/--format=gnu commands. Why?

Not looked at everything quite today, as am out of time.

llvm/lib/Object/ArchiveWriter.cpp

42

If you want to add it, please make a separate patch to remove the now-redundant object:: prefixes in this file. It can be a successor patch, if you want, or a prerequisite.

216

If there are any similar comments in your patch, please make the same change.

645–659

At the moment, I don't understand the difference between LastOffset and MaxOffset from just the variable names. I'd like either better names, and possibly even completely separate variables for AIX, to distinguish.

713–725

That's probably worth a comment or two in this code explaining why you add a null terminator in one place but not the other then.

774

Why has this become % 3? This isn't correct for tail padding to an even size.

[DiggerLin]

In D123949#3477025, @jhenderson wrote:

It looks like in the latest diff you've reinstated some XFAIL/--format=gnu commands. Why?

Not looked at everything quite today, as am out of time.

these test case generated  a empty big archive file, but there are some problem on the  reading empty big archive. so I added --format=gnu for generating the empty big archive. I will create a new patch to delete the --format=gnu after https://reviews.llvm.org/D124017 landing

[DiggerLin]

address comment and fix some bug

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

774

good catch. it is a mistake, thanks

[jhenderson]

llvm/lib/Object/ArchiveWriter.cpp

209–210

I'm not sure I understand this modulo here. I'm guessing it's intended to mirror the same thing in printRestOfMemberHeader, but in that case, it should have a comment (just like in that code).

358–359

Once using braces for part of an if/else, use it for all parts.

451–452

I feel like this comment is stale for Big Archive format.

513

(and reflow with clang-format if needed)

554–556

657

You should probably have a comment explaining why no symbol table for Big archive.

701–724

Ditto - please add a comment explaining why Big archive format is different.

707

727–728

I'm assuming the "+ 1" is for the "number of members" field? If so, I'd recommend pulling it out of the calculation, and adding a comment for it e.g.:

unsigned MemberTableSize =
    20 + // Number of members field
    20 * MemberOffsets.size() +
    MemberTableNameStrTblSize;

Conversely, I don't think you need to label the second or third parameters, since they are already named variables (plus the comment doesn't line up with my understanding of what this is).

740

Missing comment? Also, I don't understandwhy the global symbol table offset is dependent on the size of NewMembers?

750

Why is "0" quoted here, unlike in the other cases?

766

771

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

740

I added a comment in the source code.

[DiggerLin]

addressed comment. thanks James.

[jhenderson]

Just some nits left from me.

llvm/lib/Object/ArchiveWriter.cpp

658

begin is a verb, not a noun. You need beginning or start (start is probably preferable).

740

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

658

thanks

[jhenderson]

All looks good to me, but I think it would be worth getting a second pair of eyes on it (@Esme?)

[DiggerLin]

In D123949#3508905, @jhenderson wrote:

All looks good to me, but I think it would be worth getting a second pair of eyes on it (@Esme?)

sorry that not saw the comment before I commit , if Esme has comment on the patch, I will do a post-commit patch.

[bd1976llvm]

Hi @DiggerLin. Currently the --help text states --format=aix but llvm-ar accepts --format=bigarchive. Could you fix that please.

[bd1976llvm]

@DiggerLin there are a number of tests e.g: llvm\test\tools\llvm-ar\regular-to-thin-archive.test that are still marked "XFAIL: system-aix" that probably need looking at. It might be good to write down what testing strategy you want for AIX. Are you happy to rely on --format=gnu test coverage for most of the tests and have a few specifically --format=aix tests?

[DiggerLin]

In D123949#3517524, @bd1976llvm wrote:

Hi @DiggerLin. Currently the --help text states --format=aix but llvm-ar accepts --format=bigarchive. Could you fix that please.

I have a patch to fix the problem , thanks for remind me. https://reviews.llvm.org/D130292

llvm/include/llvm/Object/Archive.h

private:
   uint16_t FirstRegularStartOfFile = -1;
 
   unsigned Format : 3;
   unsigned IsThin : 1;
   mutable std::vector<std::unique_ptr<MemoryBuffer>> ThinBuffers;
 };
 
 class BigArchive : public Archive {
+public:
   /// Fixed-Length Header.
   struct FixLenHdr {
     char Magic[sizeof(BigArchiveMagic) - 1]; ///< Big archive magic string.
     char MemOffset[20];                      ///< Offset to member table.
     char GlobSymOffset[20];                  ///< Offset to global symbol table.
     char
         GlobSym64Offset[20]; ///< Offset global symbol table for 64-bit objects.
     char FirstChildOffset[20]; ///< Offset to first archive member.

llvm/lib/Object/ArchiveWriter.cpp

 #include "llvm/Object/Error.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
+#include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SmallVectorMemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <map>
 
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 using namespace llvm;
 
 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();
static void printWithSpacePadding(raw_ostream &OS, T Data, unsigned Size) {
   OS.indent(Size - SizeSoFar);
 }
 
 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 isBSDLike(object::Archive::Kind Kind) {
   switch (Kind) {
   case object::Archive::K_GNU:
   case object::Archive::K_GNU64:
+  case object::Archive::K_AIXBIG:
     return false;
   case object::Archive::K_BSD:
   case object::Archive::K_DARWIN:
   case object::Archive::K_DARWIN64:
     return true;
-  case object::Archive::K_AIXBIG:
   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) {
printBSDMemberHeader(raw_ostream &Out, uint64_t Pos, StringRef Name,
   printWithSpacePadding(Out, Twine("#1/") + Twine(NameWithPadding), 16);
   printRestOfMemberHeader(Out, ModTime, UID, GID, Perms,
                           NameWithPadding + Size);
   Out << Name;
   while (Pad--)
     Out.write(uint8_t(0));
 }
 
+static void
+printBigArchiveMemberHeader(raw_ostream &Out, StringRef Name,
+                            const sys::TimePoint<std::chrono::seconds> &ModTime,
+                            unsigned UID, unsigned GID, unsigned Perms,
+                            uint64_t Size, unsigned PrevOffset,
+                            unsigned NextOffset) {
+  unsigned NameLen = Name.size();
+
+  printWithSpacePadding(Out, Size, 20);           // File member size
+  printWithSpacePadding(Out, NextOffset, 20);     // Next member header offset
+  printWithSpacePadding(Out, PrevOffset, 20); // Previous member header offset
+  printWithSpacePadding(Out, sys::toTimeT(ModTime), 12); // File member date
+  // The big archive format has 12 chars for uid and gid.
+  printWithSpacePadding(Out, UID % 1000000000000, 12);   // UID
+  printWithSpacePadding(Out, GID % 1000000000000, 12);   // GID
+  printWithSpacePadding(Out, format("%o", Perms), 12);   // Permission
+  printWithSpacePadding(Out, NameLen, 4);                // Name length
+  if (NameLen) {
+    printWithSpacePadding(Out, Name, NameLen); // Name
+    if (NameLen % 2)
+      Out.write(uint8_t(0)); // Null byte padding
+  }
+  Out << "`\n"; // Terminator
+}
+
 static bool useStringTable(bool Thin, StringRef Name) {
   return Thin || Name.size() >= 16 || Name.contains('/');
 }
 
 static bool is64BitKind(object::Archive::Kind Kind) {
   switch (Kind) {
   case object::Archive::K_GNU:
   case object::Archive::K_BSD:
   case object::Archive::K_DARWIN:
   case object::Archive::K_COFF:
-  case object::Archive::K_AIXBIG:
     return false;
+  case object::Archive::K_AIXBIG:
   case object::Archive::K_DARWIN64:
   case object::Archive::K_GNU64:
     return true;
   }
   llvm_unreachable("not supported for writting");
 }
 
 static void
else
     Size += NumSyms * OffsetSize; // Table
   if (isBSDLike(Kind))
     Size += OffsetSize; // byte count
   Size += StringTable.size();
   // 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.
   // We do this for all bsd formats because it simplifies aligning members.
-  uint32_t Pad = offsetToAlignment(Size, Align(isBSDLike(Kind) ? 8 : 2));
+  // 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 void writeSymbolTableHeader(raw_ostream &Out, object::Archive::Kind Kind,
-                                   bool Deterministic, uint64_t Size) {
+                                   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 void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
                              bool Deterministic, ArrayRef<MemberData> Members,
-                             StringRef StringTable) {
+                             StringRef StringTable,
+                             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))
     return;
 
   unsigned NumSyms = 0;
   for (const MemberData &M : Members)
     NumSyms += M.Symbols.size();
 
   uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
   uint32_t Pad;
   uint64_t Size = computeSymbolTableSize(Kind, NumSyms, OffsetSize, StringTable, &Pad);
-  writeSymbolTableHeader(Out, Kind, Deterministic, Size);
+  writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset);
 
-  uint64_t Pos = Out.tell() + Size;
+  uint64_t Pos = isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr)
+                                       : Out.tell() + Size;
 
   if (isBSDLike(Kind))
     printNBits(Out, Kind, NumSyms * 2 * OffsetSize);
   else
     printNBits(Out, Kind, NumSyms);
 
   for (const MemberData &M : Members) {
     for (unsigned StringOffset : M.Symbols) {
getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, bool &HasObject) {
   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) {
   static char PaddingData[8] = {'\n', '\n', '\n', '\n', '\n', '\n', '\n', '\n'};
 
-  // This ignores the symbol table, but we only need the value mod 8 and the
-  // symbol table is aligned to be a multiple of 8 bytes
-  uint64_t Pos = 0;
+  uint64_t Pos =
+      isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 0;
 
   std::vector<MemberData> Ret;
   bool HasObject = false;
 
   // Deduplicate long member names in the string table and reuse earlier name
   // offsets. This especially saves space for COFF Import libraries where all
   // members have the same name.
   StringMap<uint64_t> MemberNames;
computeMemberData(raw_ostream &StringTable, raw_ostream &SymNames,
   std::map<StringRef, unsigned> FilenameCount;
   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;
   for (const NewArchiveMember &M : NewMembers) {
     std::string Header;
     raw_string_ostream Out(Header);
 
     MemoryBufferRef Buf = M.Buf->getMemBufferRef();
     StringRef Data = Thin ? "" : Buf.getBuffer();
 
     // ld64 expects the members to be 8-byte aligned for 64-bit content and at
for (const NewArchiveMember &M : NewMembers) {
     uint64_t Size = Buf.getBufferSize() + MemberPadding;
     if (Size > object::Archive::MaxMemberSize) {
       std::string StringMsg =
           "File " + M.MemberName.str() + " exceeds size limit";
       return make_error<object::GenericBinaryError>(
           std::move(StringMsg), object::object_error::parse_failed);
     }
 
+    if (isAIXBigArchive(Kind)) {
+      unsigned NextOffset = Pos + sizeof(object::BigArMemHdrType) +
+                            alignTo(M.MemberName.size(), 2) + alignTo(Size, 2);
+      printBigArchiveMemberHeader(Out, M.MemberName, ModTime, M.UID, M.GID,
+                                  M.Perms, Size, PrevOffset, NextOffset);
+      PrevOffset = Pos;
+    } else {
       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);
       if (auto E = SymbolsOrErr.takeError())
         return std::move(E);
static Error writeArchiveToStream(raw_ostream &Out,
 
   Expected<std::vector<MemberData>> DataOrErr =
       computeMemberData(StringTable, SymNames, Kind, Thin, Deterministic,
                         WriteSymtab, NewMembers);
   if (Error E = DataOrErr.takeError())
     return E;
   std::vector<MemberData> &Data = *DataOrErr;
 
-  if (!StringTableBuf.empty())
+  if (!StringTableBuf.empty() && !isAIXBigArchive(Kind))
     Data.insert(Data.begin(), computeStringTable(StringTableBuf));
 
   // We would like to detect if we need to switch to a 64-bit symbol table.
-  if (WriteSymtab) {
-    uint64_t MaxOffset = 8; // For the file signature.
-    uint64_t LastOffset = MaxOffset;
-    uint64_t NumSyms = 0;
-    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();
-      NumSyms += M.Symbols.size();
-    }
+  uint64_t LastMemberEndOffset =
+      isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 8;
+  uint64_t LastMemberHeaderOffset = LastMemberEndOffset;
+    LastMemberHeaderOffset = LastMemberEndOffset;
+    LastMemberEndOffset += M.Header.size() + M.Data.size() + M.Padding.size();
 
+  // 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 && !isAIXBigArchive(Kind)) {
     // We assume 32-bit offsets to see if 32-bit symbols are possible or not.
     uint64_t SymtabSize = computeSymbolTableSize(Kind, NumSyms, 4, SymNamesBuf);
     auto computeSymbolTableHeaderSize =
         [=] {
           SmallString<0> TmpBuf;
           raw_svector_ostream Tmp(TmpBuf);
           writeSymbolTableHeader(Tmp, Kind, Deterministic, SymtabSize);
           return TmpBuf.size();
         };
-    LastOffset += computeSymbolTableHeaderSize() + SymtabSize;
+    LastMemberHeaderOffset += computeSymbolTableHeaderSize() + SymtabSize;
 
     // 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.
     uint64_t Sym64Threshold = 1ULL << 32;
     const char *Sym64Env = std::getenv("SYM64_THRESHOLD");
     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 >= Sym64Threshold) {
+    // If LastMemberHeaderOffset 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 (LastMemberHeaderOffset >= Sym64Threshold) {
       if (Kind == object::Archive::K_DARWIN)
         Kind = object::Archive::K_DARWIN64;
       else
         Kind = object::Archive::K_GNU64;
     }
   }
 
   if (Thin)
     Out << "!<thin>\n";
+  else if (isAIXBigArchive(Kind))
+    Out << "<bigaf>\n";
   else
     Out << "!<arch>\n";
 
+  if (!isAIXBigArchive(Kind)) {
     if (WriteSymtab)
       writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf);
-
     for (const MemberData &M : Data)
       Out << M.Header << M.Data << M.Padding;
-
+  } else {
+    // For the big archive (AIX) format, compute a table of member names and
+    // offsets, used in the member table.
+    uint64_t MemberTableNameStrTblSize = 0;
+    std::vector<size_t> MemberOffsets;
+    std::vector<StringRef> MemberNames;
+    // Loop across object to find offset and names.
+    uint64_t MemberEndOffset = sizeof(object::BigArchive::FixLenHdr);
+    for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) {
+      const NewArchiveMember &Member = NewMembers[I];
+      MemberTableNameStrTblSize += Member.MemberName.size() + 1;
+      MemberOffsets.push_back(MemberEndOffset);
+      MemberNames.push_back(Member.MemberName);
+      // File member name ended with "`\n". The length is included in
+      // BigArMemHdrType.
+      MemberEndOffset += sizeof(object::BigArMemHdrType) +
+                             alignTo(Data[I].Data.size(), 2) +
+                             alignTo(Member.MemberName.size(), 2);
+    }
+
+    // AIX member table size.
+    unsigned MemberTableSize = 20 + // Number of members field
+                               20 * MemberOffsets.size() +
+                               MemberTableNameStrTblSize;
+
+    unsigned GlobalSymbolOffset =
+        (WriteSymtab && NumSyms > 0)
+            ? LastMemberEndOffset +
+                  alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2)
+            : 0;
+
+    // Fixed Sized Header.
+    printWithSpacePadding(Out, NewMembers.size() ? LastMemberEndOffset : 0,
+                          20); // Offset to member table
+    // If there are no file members in the archive, there will be no global
+    // symbol table.
+    printWithSpacePadding(Out, NewMembers.size() ? GlobalSymbolOffset : 0, 20);
+    printWithSpacePadding(
+        Out, 0,
+        20); // Offset to 64 bits global symbol table - Not supported yet
+    printWithSpacePadding(
+        Out, NewMembers.size() ? sizeof(object::BigArchive::FixLenHdr) : 0,
+        20); // Offset to first archive member
+    printWithSpacePadding(Out, NewMembers.size() ? LastMemberHeaderOffset : 0,
+                          20); // Offset to last archive member
+    printWithSpacePadding(
+        Out, 0,
+        20); // Offset to first member of free list - Not supported yet
+
+    for (const MemberData &M : Data) {
+      Out << M.Header << M.Data;
+      if (M.Data.size() % 2)
+        Out << '\0';
+    }
+
+    if (NewMembers.size()) {
+      // Member table.
+      printBigArchiveMemberHeader(Out, "", sys::toTimePoint(0), 0, 0, 0,
+                                  MemberTableSize, LastMemberHeaderOffset,
+                                  GlobalSymbolOffset);
+      printWithSpacePadding(Out, MemberOffsets.size(), 20); // Number of members
+      for (uint64_t MemberOffset : MemberOffsets)
+        printWithSpacePadding(Out, MemberOffset,
+                              20); // Offset to member file header.
+      for (StringRef MemberName : MemberNames)
+        Out << MemberName << '\0'; // Member file name, null byte padding.
+
+      if (MemberTableNameStrTblSize % 2)
+        Out << '\0'; // Name table must be tail padded to an even number of
+                     // bytes.
+
+      if (WriteSymtab && NumSyms > 0)
+        writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf,
+                         LastMemberEndOffset);
+    }
+  }
   Out.flush();
   return Error::success();
 }
 
 Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers,
                    bool WriteSymtab, object::Archive::Kind Kind,
                    bool Deterministic, bool Thin,
                    std::unique_ptr<MemoryBuffer> OldArchiveBuf) {

llvm/test/Object/ar-create.test

-XFAIL: system-aix
 Test which operations create an archive and which don't.
 
 RUN: touch %t
 RUN: rm -f %t.foo.a
 RUN: not llvm-ar p %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar d %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar m %t.foo.a %t 2>&1 | FileCheck %s
 RUN: not llvm-ar t %t.foo.a %t 2>&1 | FileCheck %s

llvm/test/Object/archive-extract-dir.test

-XFAIL: system-aix
-
 RUN: mkdir -p %t
 RUN: cd %t
 RUN: rm -rf foo
 RUN: echo foo > foo
 RUN: rm -f test.a
 RUN: llvm-ar rc          test.a foo
 RUN: rm foo
 RUN: mkdir foo
 RUN: not llvm-ar x test.a foo 2>&1 | FileCheck -DMSG=%errc_EISDIR %s
 
 CHECK: foo: [[MSG]]

llvm/test/Object/archive-malformed-object.test

-# XFAIL: system-aix
 ## Show that the archive library emits error messages when adding malformed
 ## objects.
 
 # RUN: rm -rf %t.dir
 # RUN: split-file %s %t.dir
 # RUN: cd %t.dir
 
 ## Malformed bitcode object.

llvm/test/Object/archive-replace-pos.test

-XFAIL: system-aix
-
 Test adding a member to a particular position
 
 RUN: touch %t.foo
 RUN: touch %t.bar
 RUN: rm -f %t.a
 RUN: llvm-ar rc %t.a %t.foo %t.bar
 RUN: touch %t.zed
 RUN: llvm-ar rca %t.foo %t.a %t.zed

llvm/test/Object/archive-unknown-filetype.test

-# XFAIL: system-aix
 ## Show that the archive library does not emit an error or add any symbols to
 ## the archive symbol table, when it encounters an unknown file type, but still
 ## adds the file to the archive.
 
 # RUN: echo something > %t
 # RUN: rm -f %t.a
 # RUN: llvm-ar rc %t.a %t
 # RUN: llvm-ar t %t.a | FileCheck %s --check-prefix=CONTENTS -DFILE=%basename_t
 # RUN: llvm-nm --print-armap %t.a | FileCheck %s --allow-empty --implicit-check-not={{.}}
 
 # CONTENTS: [[FILE]]

llvm/test/Object/archive-update.test

-XFAIL: system-aix
-
 Test the 'u' option of llvm-ar
 
 RUN: rm -rf %t && mkdir -p %t && cd %t
 RUN: rm -f %t/tmp.a
 
 Create a file named evenlen that is newer than the evenlen on the source dir.
 RUN: mkdir -p %t/tmp.older
 RUN: echo older > %t/tmp.older/evenlen

llvm/test/Object/directory.ll

-; XFAIL: system-aix
-
 ;RUN: rm -rf %t && mkdir -p %t
 ;RUN: not llvm-ar r %t/test.a . 2>&1 | FileCheck -DMSG=%errc_EISDIR %s
 ;CHECK: .: [[MSG]]
 
 ;RUN: rm -f %t/test.a
 ;RUN: touch %t/a-very-long-file-name
 ;RUN: llvm-ar r %t/test.a %s %t/a-very-long-file-name
 ;RUN: llvm-ar r %t/test.a %t/a-very-long-file-name
 ;RUN: llvm-ar t %t/test.a | FileCheck -check-prefix=MEMBERS %s
 ;MEMBERS-NOT: /
 ;MEMBERS: directory.ll
 ;MEMBERS: a-very-long-file-name
 ;MEMBERS-NOT: a-very-long-file-name

llvm/test/tools/llvm-ar/count.test

-# XFAIL: system-aix
 # Test the 'N' count parameter.
 
 # Get a temp clean cwd to extract into.
 RUN: rm -rf %t && mkdir -p %t && cd %t
 
 RUN: mkdir -p %t/x %t/y %t/z
 RUN: echo hello > %t/x/foo.txt
 RUN: echo cool  > %t/y/foo.txt

llvm/test/tools/llvm-ar/create.test

-XFAIL: system-aix
 ## Test the creation warning and supression of that warning.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 
 RUN: rm -f %t.warning.ar
 RUN: llvm-ar r %t.warning.ar %t1.txt %t2.txt 2>&1 \
 RUN:   | FileCheck %s -DOUTPUT=%t.warning.ar
 
 CHECK: warning: creating [[OUTPUT]]
 
 RUN: rm -f %t.supressed.ar
 RUN: llvm-ar cr %t.supressed.ar %t1.txt %t2.txt 2>&1 | count 0

llvm/test/tools/llvm-ar/dash-before-letter.test

-XFAIL: system-aix
 # Test the use of dash before key letters.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 
 RUN: rm -f %t.ar
 RUN: llvm-ar s -cr %t.ar %t1.txt
 RUN: llvm-ar -r -s %t.ar %t2.txt -s
 RUN: llvm-ar -t %t.ar | FileCheck %s
 
 CHECK:      1.txt
 CHECK-NEXT: 2.txt

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

-; REQUIRES: system-aix
-;; Test llvm-ar does not support Big AIX archive write operation.
-
+;; Test llvm-ar uses the big archive format for XCOFF object files by default. 
 ; RUN: yaml2obj %S/Inputs/xcoff.yaml -o %t.obj
 ; RUN: rm -f %t.ar
-; RUN: not llvm-ar cr %t.ar %t.obj 2>&1 | FileCheck %s
-; RUN: echo "test big archive" > %t.txt
-; RUN: not llvm-ar cr %t.ar %t.txt 2>&1 | FileCheck %s
+; RUN: llvm-ar cr %t.ar %t.obj
+; RUN: FileCheck %s --input-file=%t.ar
 
-; CHECK: big archive writer operation on AIX not yet supported
+; CHECK:  bigaf

llvm/test/tools/llvm-ar/display-empty.test

-# XFAIL: system-aix
 ## Test Display of empty archives.
 
 # RUN: rm -rf %t && mkdir -p %t
 
 ## Display empty archive:
-# RUN: llvm-ar cr %t/empty.a
+# RUN: llvm-ar cr --format=gnu %t/empty.a
 # RUN: llvm-ar tv %t/empty.a 2>&1 | count 0
 
 ## Display empty thin archive:
 # RUN: llvm-ar Trc %t/thin-archive-empty.a
 # RUN: llvm-ar tv %t/thin-archive-empty.a 2>&1 | count 0

llvm/test/tools/llvm-ar/double-hyphen.test

-# XFAIL: system-aix
 ## Test the use of "--" on the commandline
 
 # RUN: echo contents > %t.txt
 
 # RUN: rm -f %t.ar
 # RUN: llvm-ar rc -- %t.ar %t.txt 2>&1 | count 0
 
 # RUN: llvm-ar p %t.ar | FileCheck %s
 # CHECK: contents

llvm/test/tools/llvm-ar/error-opening-permission.test

-# XFAIL: system-aix
 ## Unsupported on windows as marking files "unreadable"
 ## is non-trivial on windows.
 # UNSUPPORTED: system-windows
 
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: echo file1 > %t/1.txt
 
 ## No Permission:
 # RUN: llvm-ar rc %t/permission.b %t/1.txt
 # RUN: chmod 100 %t/permission.b
 # RUN: not llvm-ar p %t/permission.b 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=NO-PERMISSION -DARCHIVE=%t/permission.b -DMSG=%errc_EACCES
 
 # NO-PERMISSION: error: unable to open '[[ARCHIVE]]': [[MSG]]

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

 ## Test extract operation.
-# XFAIL: system-darwin,system-aix
+# XFAIL: system-darwin
 
 # RUN: rm -rf %t && mkdir -p %t/extracted/
 
 ## Extracting from an empty archive should not warn or error:
-# RUN: llvm-ar cr %t/empty.a
+# RUN: llvm-ar cr --format=gnu %t/empty.a
 # RUN: llvm-ar xv %t/empty.a 2>&1 | count 0
 
 # RUN: echo filea > %t/a.txt
 # RUN: echo fileb > %t/b.txt
 # RUN: llvm-ar rc %t/archive.a %t/a.txt %t/b.txt
 
 ## Single member:
 # RUN: cd %t/extracted && llvm-ar xv %t/archive.a a.txt | FileCheck %s --check-prefix=A

llvm/test/tools/llvm-ar/flatten-thin-archive.test

-# XFAIL: system-aix
 ## This test creates a thin archive that contains a thin archive, a regular
 ## archive, and a file.
 ##
 ## The inner thin archive should be flattened, but the regular archive should
 ## not. The order of members in the archive should match the input order, with
 ## flattened members appearing together.
 
 # RUN: touch %t-a.txt %t-b.txt %t-c.txt %t-d.txt %t-e.txt

llvm/test/tools/llvm-ar/full-path-option.test

-XFAIL: system-aix
 # Note: many of these tests depend on relative paths, so we have to cd to a
 # test directory first.
 RUN: mkdir -p %t && cd %t
 RUN: rm -rf a b && mkdir a b
 RUN: echo hello-a      > a/foo.txt
 RUN: echo hello-b      > b/foo.txt
 RUN: echo hello-parent > foo.txt
 

 RUN: llvm-ar t display.a a/foo.txt | FileCheck %s --check-prefix=DISPLAY-FOUND --match-full-lines
 RUN: not llvm-ar tP display.a a/foo.txt 2>&1 | FileCheck %s --check-prefix=DISPLAY-NOT-FOUND
 
 DISPLAY-FOUND: foo.txt
 DISPLAY-NOT-FOUND: 'a/foo.txt' was not found
 
 # Deleting will fail with P because the members exist as foo.txt, not a/foo.txt.
 RUN: rm -f del1.a
-RUN: llvm-ar rcS del1.a foo.txt
+RUN: llvm-ar rcS --format=gnu del1.a foo.txt
 RUN: llvm-ar dP del1.a a/foo.txt
 RUN: llvm-ar t del1.a a/foo.txt | FileCheck %s --check-prefix=DISPLAY-FOUND --match-full-lines
 RUN: llvm-ar d del1.a a/foo.txt
 RUN: not llvm-ar t del1.a a/foo.txt 2>&1 | FileCheck %s --check-prefix=DISPLAY-NOT-FOUND
 
 # Run several checks that P is implied when using thin archives. None of these
 # checks explicitly use P.
 

llvm/test/tools/llvm-ar/insert-after.test

-XFAIL: system-aix
 ## Test inserting files after a file.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 RUN: touch %t3.txt
 RUN: touch %t4.txt
 
 # Insert one file:

llvm/test/tools/llvm-ar/insert-before.test

-XFAIL: system-aix
 ## Test inserting files before a file.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 RUN: touch %t3.txt
 RUN: touch %t4.txt
 
 # Insert one file:

llvm/test/tools/llvm-ar/move-after.test

-XFAIL: system-aix
 ## Test moving files after a file.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 RUN: touch %t3.txt
 RUN: touch %t4.txt
 
 # Move one file:

llvm/test/tools/llvm-ar/move-before.test

-XFAIL: system-aix
 ## Test moving files after a file.
 
 RUN: touch %t1.txt
 RUN: touch %t2.txt
 RUN: touch %t3.txt
 RUN: touch %t4.txt
 
 # Move one file:

llvm/test/tools/llvm-ar/mri-delete.test

-XFAIL: system-aix
 RUN: yaml2obj %S/Inputs/elf.yaml -o %t.o
 RUN: rm -f %t.ar
 
 RUN: echo "create %t.ar;comment" > %t.mri
 RUN: echo "addmod %t.o * comment" >> %t.mri
 RUN: echo "; comment" >> %t.mri
 RUN: echo " ;comment" >> %t.mri
 RUN: echo "* comment" >> %t.mri

llvm/test/tools/llvm-ar/mri-nonascii.test

-XFAIL: system-aix
 # Test non-ascii archive members
 
 RUN: rm -rf %t && mkdir -p %t/extracted
 
 # Note: lit's Python will read this UTF-8 encoded mri-nonascii.txt file,
 # decode it to unicode. The filename in the redirection below will then
 # be encoded in the system's filename encoding (e.g. UTF-16 for
 # Microsoft Windows).

llvm/test/tools/llvm-ar/non-windows-name-case.test

-# XFAIL: system-aix
 ## Test that on windows, members are case insensitive.
 # UNSUPPORTED: system-windows
 
 # RUN: mkdir -p %t
 # RUN: rm -rf %t/lowerCase %t/UPPERCASE && mkdir %t/lowerCase %t/UPPERCASE
 # RUN: echo lowerCase > %t/lowerCase/file.txt
 # RUN: echo UPPERCASE > %t/UPPERCASE/FILE.TXT
 

llvm/test/tools/llvm-ar/plugin.test

-# XFAIL: system-aix
 ## Test that --plugin is ignored.
 
 # RUN: rm -f %t.a
 # RUN: touch %t.txt
 # RUN: llvm-ar rc %t.a %t.txt
 # RUN: llvm-ar --plugin ignore t %t.a | FileCheck %s
 # RUN: llvm-ar t --plugin=ignore %t.a | FileCheck %s
 
 # CHECK: {{.*}}.txt

llvm/test/tools/llvm-ar/print.test

 ## Test Print output
-# XFAIL: system-darwin,system-aix
+# XFAIL: system-darwin
 
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: echo file1 > %t/1.txt
 # RUN: echo file2 > %t/2.txt
 # RUN: echo file3 > %t/3.txt
 
 # RUN: llvm-ar -rc %t/archive.a %t/1.txt %t/2.txt %t/3.txt
 
 ## Print empty archive:
-# RUN: llvm-ar cr %t/empty.a
+# RUN: llvm-ar --format=gnu  cr %t/empty.a
 # RUN: llvm-ar p %t/empty.a 2>&1 | count 0
 # RUN: llvm-ar pv %t/empty.a 2>&1 | count 0
 
 ## Print without member:
 # RUN: llvm-ar p %t/archive.a \
 # RUN:   | FileCheck %s --check-prefix=WITHOUT --match-full-lines --implicit-check-not {{.}}
 
 # WITHOUT:      file1

llvm/test/tools/llvm-ar/read-only-archive.test

-# XFAIL: system-aix
 ## Test that read-only archives cannot be edited
 
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: touch %t/1.txt
 # RUN: touch %t/2.txt
 # RUN: touch %t/3.txt
 
 # RUN: llvm-ar rc %t/archive.a %t/1.txt %t/2.txt

llvm/test/tools/llvm-ar/response-utf8.test

-# XFAIL: system-aix
 ## Check that response files can cope with non-ascii characters.
 
 # RUN: echo 'contents' > %t-£.txt
 
 # RUN: rm -f %t-£.a
 # RUN: echo 'r %t-£.a %t-£.txt' > %t-replace.txt
 # RUN: llvm-ar @%t-replace.txt
 
 # RUN: echo 'p %t-£.a %t-£.txt' > %t-print.txt
 # RUN: llvm-ar @%t-print.txt | FileCheck %s
 # CHECK: contents

llvm/test/tools/llvm-ar/response.test

-# XFAIL: system-aix
 ## llvm-ar should be able to consume response files.
 
 # RUN: echo 'contents' > %t.txt
 # RUN: echo 'rc %t1.a %t.txt' > %t.response1.txt
 # RUN: llvm-ar @%t.response1.txt
 # RUN: llvm-ar p %t1.a | FileCheck %s --check-prefix=CONTENTS
 
 ## Quotes and Spaces.

llvm/test/tools/llvm-libtool-darwin/archive-flattening.test

-# XFAIL: system-aix
 ## This test checks that an archive is flattened correctly.
 
 # RUN: yaml2obj %S/Inputs/input1.yaml -o %t-input1.o
 # RUN: yaml2obj %S/Inputs/input2.yaml -o %t-input2.o
 # RUN: llvm-as %S/Inputs/x86_64-osx.ll -o %t-x86_64.bc
 
 ## Input a correct archive:
 # RUN: rm -f %t.correct.ar

llvm/test/tools/llvm-link/archive.ll

 # RUN: llvm-as %S/Inputs/f.ll -o %t.f.bc
 # RUN: llvm-as %S/Inputs/g.ll -o %t.g.bc
-# RUN: llvm-ar cr --format=gnu %t.fg.a %t.f.bc %t.g.bc
-# RUN: llvm-ar cr --format=gnu  %t.empty.lib
+# RUN: llvm-ar cr %t.fg.a %t.f.bc %t.g.bc
+# RUN: llvm-ar cr --format=gnu %t.empty.lib
 # RUN: llvm-link %S/Inputs/h.ll %t.fg.a %t.empty.lib -o %t.linked.bc
 
 # RUN: llvm-nm %t.linked.bc | FileCheck %s
 
 # RUN: rm -f %t.f.bc
 # RUN: rm -f %t.g.bc
 # RUN: rm -f %t.fg.a
 # RUN: rm -f %t.empty.a
 # RUN: rm -f %t.linked.bc
 
 # CHECK: -------- T f
 # CHECK: -------- T g
 # CHECK: -------- T h

llvm/test/tools/llvm-link/archivell.ll

-# RUN: llvm-ar --format=gnu cr %t.fg.a %S/Inputs/f.ll %S/Inputs/g.ll
+# XFAIL: system-aix
+# RUN: llvm-ar cr %t.fg.a %S/Inputs/f.ll %S/Inputs/g.ll
 # RUN: not llvm-link %S/Inputs/h.ll %t.fg.a -o %t.linked.bc 2>&1 | FileCheck %s
 
 # RUN: rm -f %t.fg.a
 # RUN: rm -f %t.linked.bc
 
 # CHECK: error: member of archive is not a bitcode file

llvm/test/tools/llvm-lipo/create-archive-input.test

 # RUN: yaml2obj %p/Inputs/i386-slice.yaml -o %t-i386.o
 # RUN: yaml2obj %p/Inputs/x86_64-slice.yaml -o %t-x86_64.o
 # RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml -o %t-universal.o
 # RUN: llvm-as %p/Inputs/armv7-ios.ll -o %t-ir-armv7.o
 # RUN: llvm-as %p/Inputs/x64-osx.ll -o %t-ir-x86_64.o
 
-# RUN: llvm-ar --format=gnu cr %t.empty.a
+# RUN: llvm-ar cr --format=gnu %t.empty.a
 # RUN: not llvm-lipo %t.empty.a -create -output /dev/null 2>&1 | FileCheck --check-prefix=EMPTY-ARCHIVE %s
 
-# RUN: llvm-ar --format=gnu cr %t.different_architectures.a %t-i386.o %t-x86_64.o
+# RUN: llvm-ar cr %t.different_architectures.a %t-i386.o %t-x86_64.o
 # RUN: not llvm-lipo %t.different_architectures.a -create -output /dev/null 2>&1 | FileCheck --check-prefix=ARCHIVE-WITH-DIFFERENT-ARCHS %s
 
-# RUN: llvm-ar --format=gnu cr %t.contains_fat_binary.a %t-universal.o 
+# RUN: llvm-ar cr %t.contains_fat_binary.a %t-universal.o 
 # RUN: not llvm-lipo %t.contains_fat_binary.a -create -output /dev/null 2>&1 | FileCheck --check-prefix=ARCHIVE-WITH-FAT-BINARY %s
 
-# RUN: llvm-ar --format=gnu cr %t-i386-lib.a %t-i386.o
+# RUN: llvm-ar cr %t-i386-lib.a %t-i386.o
 # RUN: llvm-lipo %t-i386-lib.a %t-x86_64.o -create -output %t-i386-x86_64-universal.o
 # RUN: llvm-lipo %t-i386-x86_64-universal.o -info | FileCheck --check-prefix=INFO-i386-x86_64 %s
 # RUN: llvm-lipo %t-i386-x86_64-universal.o -thin i386 -output %t-extracted-i386-lib.a
 # RUN: cmp %t-extracted-i386-lib.a %t-i386-lib.a
 # RUN: llvm-lipo %t-i386-x86_64-universal.o -thin x86_64 -output %t-extracted-x86_64.o
 # RUN: cmp %t-extracted-x86_64.o %t-x86_64.o
 
-# RUN: llvm-ar --format=gnu cr %t-ir-armv7-lib.a %t-ir-armv7.o
+# RUN: llvm-ar cr %t-ir-armv7-lib.a %t-ir-armv7.o
 # RUN: llvm-lipo %t-ir-armv7-lib.a %t-ir-x86_64.o -create -output %t-ir-armv7-x86_64-universal.o
 # RUN: llvm-lipo %t-ir-armv7-x86_64-universal.o -thin armv7 -output %t-ir-extracted-armv7-lib.a
 # RUN: cmp %t-ir-extracted-armv7-lib.a %t-ir-armv7-lib.a
 # RUN: llvm-lipo %t-ir-armv7-x86_64-universal.o -thin x86_64 -output %t-ir-extracted-x86_64.o
 # RUN: cmp %t-ir-extracted-x86_64.o %t-ir-x86_64.o
 
-# RUN: llvm-ar --format=gnu cr %t.different_types0.a %t-i386.o %t-ir-x86_64.o
+# RUN: llvm-ar cr %t.different_types0.a %t-i386.o %t-ir-x86_64.o
 # RUN: not llvm-lipo -create %t.different_types0.a -output /dev/null 2>&1 | FileCheck --check-prefix=ARCHIVE-WITH-MACHO-AND-IR %s
-# RUN: llvm-ar --format=gnu cr %t.different_types1.a %t-ir-x86_64.o %t-i386.o 
+# RUN: llvm-ar cr %t.different_types1.a %t-ir-x86_64.o %t-i386.o 
 # RUN: not llvm-lipo -create %t.different_types1.a -output /dev/null 2>&1 | FileCheck --check-prefix=ARCHIVE-WITH-IR-AND-MACHO %s
-# RUN: llvm-ar --format=gnu cr %t.different_architectures_ir.a %t-ir-x86_64.o %t-ir-armv7.o
+# RUN: llvm-ar cr %t.different_architectures_ir.a %t-ir-x86_64.o %t-ir-armv7.o
 # RUN: not llvm-lipo -create %t.different_architectures_ir.a -output /dev/null 2>&1 | FileCheck --check-prefix=ARCHIVE-WITH-DIFFERENT-ARCHS %s
 
 # EMPTY-ARCHIVE: empty archive
 # ARCHIVE-WITH-DIFFERENT-ARCHS: all members must match
 # ARCHIVE-WITH-MACHO-AND-IR: is an LLVM IR object, while previous archive member {{.*}} was a MachO
 # ARCHIVE-WITH-IR-AND-MACHO: is a MachO, while previous archive member {{.*}} was an IR LLVM object
 # ARCHIVE-WITH-FAT-BINARY: fat file (not allowed in an archive)
 #
 # INFO-i386-x86_64: i386 x86_64

llvm/test/tools/llvm-nm/option-X.test

FileHeader:
   Data:    ELFDATA2LSB
   Type:    ET_REL
 Symbols:
   - Name:    [[CLASS]]_var
 
 # RUN: yaml2obj --docnum=2 -DFLAG=0x1DF %s -o %t_xcoff32.o
 # RUN: yaml2obj --docnum=2 -DFLAG=0x1F7 %s -o %t_xcoff64.o
 # RUN: rm -f %t.a
-# RUN: llvm-ar --format=gnu -q -c %t.a %t_xcoff32.o %t_xcoff64.o
+# RUN: llvm-ar -q -c %t.a %t_xcoff32.o %t_xcoff64.o
 
 # RUN: llvm-nm --format=just-symbols -X32 %t_xcoff32.o | \
 # RUN:   FileCheck --check-prefixes=XCOFF32 %s --implicit-check-not={{.}}
 # RUN: llvm-nm --format=just-symbols -X32 %t.a | \
 # RUN:   FileCheck --check-prefixes=ARC32,XCOFF32 %s -DFILE=%basename_t --implicit-check-not={{.}}
 # ARC32:      [[FILE]].tmp_xcoff32.o:
 # XCOFF32:      var_0x1DF
 

llvm/test/tools/llvm-objcopy/MachO/universal-object.test

 # This test verifies that llvm-objcopy copies a univeral Mach-O object file properly.
 
 # RUN: yaml2obj %p/Inputs/i386.yaml -o %t.i386
 # RUN: yaml2obj %p/Inputs/x86_64.yaml -o %t.x86_64
 
 ## Case 1: copy a universal object containing regular Mach-O objects.
 # RUN: llvm-lipo %t.i386 %t.x86_64 -create -output %t.universal
 # RUN: llvm-objcopy %t.universal %t.universal.copy
 # RUN: llvm-lipo %t.universal.copy -archs | FileCheck --check-prefix=VERIFY_ARCHS %s
 # RUN: llvm-lipo %t.universal.copy -thin i386 -output %t.i386.copy
 # RUN: llvm-lipo %t.universal.copy -thin x86_64 -output %t.x86_64.copy
 # RUN: cmp %t.i386 %t.i386.copy
 # RUN: cmp %t.x86_64 %t.x86_64.copy
 
 ## Case 2: copy a universal object file containing an archive.
 # RUN: rm -f %t.archive.i386
-# RUN: llvm-ar --format=gnu cr %t.archive.i386 %t.i386
+# RUN: llvm-ar cr %t.archive.i386 %t.i386
 # RUN: llvm-lipo %t.archive.i386 %t.x86_64 -create -output %t.universal.containing.archive
 # RUN: llvm-objcopy %t.universal.containing.archive %t.universal.containing.archive.copy
 # RUN: llvm-lipo %t.universal.containing.archive.copy -archs | FileCheck --check-prefix=VERIFY_ARCHS %s
 # RUN: llvm-lipo %t.universal.containing.archive.copy -thin i386 -output %t.archive.i386.copy
 # RUN: llvm-lipo %t.universal.containing.archive.copy -thin x86_64 -output %t.archive.x86_64.copy
 # RUN: cmp %t.archive.i386 %t.archive.i386.copy
 # RUN: cmp %t.x86_64 %t.archive.x86_64.copy
 
 ## Case 3: copy an archive containing a universal object.
-# RUN: llvm-ar --format=gnu cr %t.archive.containing.universal %t.universal
+# RUN: llvm-ar cr %t.archive.containing.universal %t.universal
 # RUN: llvm-objcopy %t.archive.containing.universal %t.archive.containing.universal.copy
 
 ## Case 4: try to copy a universal object file contaning a bitcode slice.
 # RUN: echo 'target triple = "arm64-apple-ios8.0.0"' | llvm-as -o %t.bitcode
 # RUN: llvm-lipo %t.bitcode  %t.x86_64 -create -output %t.universal.containing.bitcode
 # RUN: not llvm-objcopy %t.universal.containing.bitcode %t.universal.containing.bitcode.copy 2>&1 \
 # RUN:  | FileCheck --check-prefix=UNSUPPORTED_UNIVERSAL_OBJECT %s
 
 ## Case 5: try to copy an archive containing an unsupported universal object.
-# RUN: llvm-ar --format=gnu cr %t.archive.universal.bitcode %t.universal.containing.bitcode
+# RUN: llvm-ar cr %t.archive.universal.bitcode %t.universal.containing.bitcode
 # RUN: not llvm-objcopy %t.archive.universal.bitcode %t.archive.universal.bitcode.copy 2>&1 \
 # RUN:  | FileCheck --check-prefix=UNSUPPORTED_UNIVERSAL_OBJECT %s
 
 # VERIFY_ARCHS: i386 x86_64
 # UNSUPPORTED_UNIVERSAL_OBJECT: slice for 'arm64' of the universal Mach-O binary {{.*}} is not a Mach-O object or an archive

llvm/test/tools/llvm-readobj/basic.test

 
 # Test case where input file is too small to be a recognised object file.
 RUN: touch %t.empty
 RUN: not llvm-readobj %t.empty 2>&1 | FileCheck --check-prefix=EMPTY %s
 EMPTY: '{{.*}}.empty': The file was not recognized as a valid object file
 
 # Test that unrecognised files in archives are ignored.
 RUN: rm -f %t.a
-RUN: llvm-ar --format=gnu rc %t.a %t.empty
+RUN: llvm-ar rc %t.a %t.empty
 RUN: llvm-readobj --all %t.a 2>&1 | FileCheck --check-prefix=NO-OUTPUT --allow-empty %s
 NO-OUTPUT-NOT: {{.}}
 
 ## Test we report a meaningful warning for bitcode files.
 ## Check we try to continue dumping other files.
 
 ## Note: 'echo -e -n "\x42\x43\xc0\xde" > %t.bc.1' simply doesn't work properly on windows.
 ## It has an issue with writing of the 2 last bytes and emits different data instead.

llvm/test/tools/llvm-size/archive.test

 ## Show how llvm-size behaves when passed in an archive.
 
 # RUN: yaml2obj %s --docnum=1 -o %t1
 # RUN: yaml2obj %s --docnum=2 -o %t2
 
 ## Case 1: Empty archive. No output expected.
 # RUN: rm -f %t1.a
-# RUN: llvm-ar --format=gnu rc %t1.a
+# RUN: llvm-ar rc --format=gnu %t1.a
 
 # RUN: llvm-size -B %t1.a | count 0
 # RUN: llvm-size -A %t1.a | count 0
 
 ## Case 2: Single member.
 # RUN: rm -f %t2.a
-# RUN: llvm-ar --format=gnu rc %t2.a %t1
+# RUN: llvm-ar rc %t2.a %t1
 
 # RUN: llvm-size -B %t2.a | FileCheck %s -DARCHIVE=%t2.a --check-prefix=BERKELEY-1
 # RUN: llvm-size -A %t2.a | FileCheck %s -DARCHIVE=%t2.a --check-prefix=SYSV-1
 
 ## Case 3: Multiple members.
 # RUN: rm -f %t3.a
-# RUN: llvm-ar --format=gnu rc %t3.a %t1 %t2
+# RUN: llvm-ar rc %t3.a %t1 %t2
 
 # RUN: llvm-size -B %t3.a | FileCheck %s -DARCHIVE=%t3.a --check-prefixes=BERKELEY-1,BERKELEY-2
 # RUN: llvm-size -A %t3.a | FileCheck %s -DARCHIVE=%t3.a --check-prefixes=SYSV-1,SYSV-2
 
 ## Case 4: Mixing archives and non-archives produces sensible output:
 # RUN: llvm-size -B %t1 %t2.a %t2 %t3.a \
 # RUN:   | FileCheck %s -DARCHIVE=%t3.a -DARCHIVE2=%t2.a -DFILE1=%t1 -DFILE2=%t2 \
 # RUN:                  --check-prefixes=BERKELEY-1,BERKELEY-2,BERKELEY-3

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

 static void printArHelp(StringRef ToolName) {
   const char ArOptions[] =
       R"(OPTIONS:
   --format              - archive format to create
     =default            -   default
     =gnu                -   gnu
     =darwin             -   darwin
     =bsd                -   bsd
+    =aix                -   aix (big archive)
   --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>
static void failIfError(Error E, Twine Context = "") {
   });
 }
 
 static SmallVector<const char *, 256> PositionalArgs;
 
 static bool MRI;
 
 namespace {
-enum Format { Default, GNU, BSD, DARWIN, Unknown };
+enum Format { Default, GNU, BSD, DARWIN, BIGARCHIVE, Unknown };
 }
 
 static Format FormatType = Default;
 
 static std::string Options;
 
 // This enumeration delineates the kinds of operations on an archive
 // that are permitted.
case Default:
     else if (OldArchive)
       Kind = OldArchive->kind();
     else if (NewMembersP)
       Kind = !NewMembersP->empty() ? getKindFromMember(NewMembersP->front())
                                    : getDefaultForHost();
     else
       Kind = !NewMembers.empty() ? getKindFromMember(NewMembers.front())
                                  : getDefaultForHost();
-    if (Kind == object::Archive::K_AIXBIG)
-      fail("big archive writer operation on AIX not yet supported");
     break;
   case GNU:
     Kind = object::Archive::K_GNU;
     break;
   case BSD:
     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 BIGARCHIVE:
+    if (Thin)
+      fail("only the gnu format has a thin mode");
+    Kind = object::Archive::K_AIXBIG;
+    break;
   case Unknown:
     llvm_unreachable("");
   }
 
   Error E =
       writeArchive(ArchiveName, NewMembersP ? *NewMembersP : NewMembers, Symtab,
                    Kind, Deterministic, Thin, std::move(OldArchiveBuf));
   failIfError(std::move(E), ArchiveName);
for (ArrayRef<const char *>::iterator ArgIt = Argv.begin();
 
     Match = matchFlagWithArg("format", ArgIt, Argv);
     if (Match) {
       FormatType = StringSwitch<Format>(Match)
                        .Case("default", Default)
                        .Case("gnu", GNU)
                        .Case("darwin", DARWIN)
                        .Case("bsd", BSD)
+                       .Case("bigarchive", BIGARCHIVE)
                        .Default(Unknown);
       if (FormatType == Unknown)
         fail(std::string("Invalid format ") + Match);
       continue;
     }
 
     if (matchFlagWithArg("plugin", ArgIt, Argv) ||
         matchFlagWithArg("rsp-quoting", ArgIt, Argv))