[AIX] support 64bit global symbol table for big archive

[DiggerLin]

Summary

In big archive , there is 32bit global symbol table and 64 bit global symbol table. llvm-ar only support 32bit global symbol table this moment, we need to support the 64 bit global symbol table.

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

Global Symbol Tables

Immediately following the member table, the archive file contains two global symbol tables. The first global symbol table locates 32-bit file members that define global symbols; the second global symbol table does the same for 64-bit file members. If the archive has no 32-bit or 64-bit file members, the respective global symbol table is omitted. The strip command can be used to delete one or both global symbol tables from the archive. The fl_gstoff field in the fixed-length header contains the offset to the 32-bit global symbol table, and the fl_gst64off contains the offset to the 64-bit global symbol table.

[jhenderson]

I'm out of time for now. Please take a look at my inline comments and I'll come back to this at some point after you've addressed them (I have a big backlog to catch up on, so it may be a while).

llvm/include/llvm/Object/Archive.h

408

I think it's unlikely that this buffer is ever going to be "small", so it seems likely that it would just be better to store this a std::string ultimately.

llvm/lib/Object/Archive.cpp

1181

These new returns seem like they should be a separate patch. They aren't really anything to do with 64-bit global symbol table support.

1195

1214–1216

I would avoid long lambdas like this, as they make it hard to follow the code flow. Instead, I'd pull it into a separate function. You can have it return Error too, rather than passing in the error as a reference.

1252

1259

1273

Again, I'd prefer this to be a separate function.

1296

This code all feels a bit too procedural. I think you could make things a little neater by introducing a small SymbolTableReader class. Something like the following rough outline:

class SymbolTableReader {
public:
  void readTable(...) {
    assert(MergedSymbolOffsets.empty() && MergedStringTables.empty()); // readTable should only be called before the getters.
    SymbolOffsets.push_back(...); // Add the offsets for this individual table
    StringTable.push_back(...); // Add the strings for this individual table.
  }

  StringRef getSymbolOffsetTable() const {
    if (SymbolOffsets.size() == 1)
      return SymbolOffsets[0];
    if (!MergedSymbolOffsets.empty())
      return MergedSymbolOffsets;

    uint64_t SymCount = 0;
    for (StringRef SymbolOffsetTable : SymbolOffsets)
      SymCount += /* read sym count */;
    raw_svector_ostream Stream(MergedSymbolOffsets);
    // Write the SymCount to the stream.
    // Loop over and write the symbol offsets to the stream.
    return MergedSymbolOffsets;
  }

  StringRef getStringTable() const {
    if (StringTables.size() == 1)
      return StringTables[0];
    if (!MergedStringTables.empty())
      return MergedStringTables;

    // Combine all the strings in StringTables and store in MergedStringTables
    return MergedStringTables;
  }

private:
  StringRefVector SymbolOffsets;
  StringRefVector StringTables;

  mutable std::string MergedSymbolOffsets;
  mutable std::string MergedStringTables;
};

llvm/lib/Object/ArchiveWriter.cpp

423

The fact that there's another is64BitSymbolFile() should tell you that you need to reorganise some code to avoid code duplication.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

408

there are null characters between each symbol name to separate the symbol names in the global symbol table, I do not think we can use the std::string to store it.

and the base class of SmallString is SmallVector, According to the comment in the SmallVector.h, "SmallVectors are used for buffering bitcode output - which can exceed 4GB.",

llvm/lib/Object/ArchiveWriter.cpp

423

I createed a new NFC patch (https://reviews.llvm.org/D143097) which will add a new virtual API Is64bit() for SymbolicFile

[DiggerLin]

In D142479#4090280, @jhenderson wrote:

I'm out of time for now. Please take a look at my inline comments and I'll come back to this at some point after you've addressed them (I have a big backlog to catch up on, so it may be a while).

Thanks a lot for your time to review.

[jhenderson]

llvm/include/llvm/Object/Archive.h

408

there are null characters between each symbol name to separate the symbol names in the global symbol table, I do not think we can use the std::string to store it.

std::string is perfectly capable of storing null bytes. You just can't use the std::string(const char *) constructor to build it (you need to use one which takes a size too).

and the base class of SmallString is SmallVector, According to the comment in the SmallVector.h, "SmallVectors are used for buffering bitcode output - which can exceed 4GB.",

Have you read the Programmer's Manual? FWIW, I couldn't figure out from that which is the more appropriate to use. I guess in the end, it'll depend on how you end up populating it as to which is better.

[DiggerLin]

address comment and add bit code into test case.

llvm/lib/Object/Archive.cpp

1181

OK, I will do it.

1296

when class Archive , it need set two member

StringRef SymbolTable;
 StringRef StringTable;

for symbol iterating.

we do not need a variable "SymbolOffsets" here.

and for getStringTable() in your comment, also only use once for setting the "StringTable" of class Archive.

And the code use in my patch only 18 lines which including the merging of 32bit global symbol table and 64 bit global symbol table into a one and setting the two variable of Archive class (SymbolTable and StringTable), I think it is easy to understand.

but I get some idea from your comment to introduce the a new structure to reduce the variables.

[DiggerLin]

fixed a bug

[DiggerLin]

gentle ping.

[DiggerLin]

gentle ping. if you have time , would you like to take sometime to review @jhenderson

[jhenderson]

Sorry for taking a long time to review this. Also, it will be important that somebody with AIX familiarity reviews this.

llvm/include/llvm/Object/Archive.h

408

See my comments elsewhere about naming.

llvm/lib/Object/Archive.cpp

1171

Use lower-case for function names (as stated before), and don't abbreviate things if the meaning can become ambiguous ("Glob" could refer to "Glob patterns" and is not obviously referring to Global).

Also, "Symtab" is a more common way of shortening "symbol table", so you may wish to change all your "SymTbl" names to that, although I'm less bothered by that one.

1190

You're being inconsistent with your "malformed AIX big archive" prefixes. You have it here, but not in the other error messages in the function.

1210

Either return a vector from the function, rather than pass it by reference, or change the function name to appendGlobalSymbolTableInfo or something to that effect, to better describe what it is doing.

1297–1299

1310

Why "8"? It would be better to avoid "magic numbers" like this. Give them names, or better yet directly use sizeof or similar to derive the value.

llvm/lib/Object/ArchiveWriter.cpp

408

I'd rename this to match the type you're fetching.

409

Move this variable declaration to where it is used for the first time.

411

I suggest this should be "Don't attempt to read non-symbolic file types."

428

I'm looking at this method again and I'm a little concerned that we end up potentially reading each member multiple times, which is not going to be a fast operation. I seem to remember (possibly in an unrelated patch - I've been looking at too many different ones to keep things straight) that you stored the SymbolicFile class as a member of the Archive member class, to avoid this issue elsewhere. Could you make use of that here, to avoid the additional reading in that this file?

438

496–497

To clarify, will getSymbol definitely always have been called before this point (no matter the options/contents of file etc)? If not, is it definitely always called afterwards?

499

Is there any code path that can hit this code when an error is present? If so, then you're going to get a crash on the line after this consumeError call, so you need to do something to fix that. If not, then this should be cantFail, not consumeError. The same goes for the consumeError call a little ways below.

535

756

Use "32-bit" when it is used as an adjective before the noun (as here). Use "32-bits" when it is not followed by a noun (e.g. "this file is 32-bits").

765–770

Some wording suggestions. Please reflow as appropriate.

I've added "may" before "contain", on the assumption that an AIX big archive with only 32-bit members won't contain a 64-bit symbol table. If it is always present, please delete the "may" from the first sentence.

861

875–876

Field names in the comment don't match the variable names. Are the field names different?

892–893

940

945–946

I think this comment would be a little clearer.

948

The style elsewhere uses the suggested edit.

951

[DiggerLin]

address comments, thanks James.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

408

thanks

llvm/lib/Object/Archive.cpp

1190

there is " truncated or malformed archive" output for malformedError ,I delete the "malformed AIX big archive: " .

I will delete other "malformed AIX big archive:" in a separate patch.

llvm/lib/Object/ArchiveWriter.cpp

428

I only added two new members for struct MemberData

uint64_t PreHeadPadSize = 0;
 std::unique_ptr<SymbolicFile> SymFile = nullptr;

I think you maybe want to mention the comment https://reviews.llvm.org/D142479#inline-1379936

496–497

The function writeSymbolTable is called only when "WriteSymtab is true"

there is two places call the is64BitSymbolicFile(M.Data) before the function writeSymbolTable() be called.

1. in function writeArchiveToStream()

if (isAIXBigArchive(Kind) && WriteSymtab) {
    Expected<bool> Is64BitOrErr = is64BitSymbolicFile(M.Data);
    if (Error E = Is64BitOrErr.takeError())
      return E;

    if (!*Is64BitOrErr)
      NumSyms32 += M.Symbols.size();
  }

2. In computeMemberData

if (NeedSymbols) {
  Expected<std::vector<unsigned>> SymbolsOrErr =
      getSymbols(Buf, SymNames, HasObject);
  if (!SymbolsOrErr)
    return createFileError(M.MemberName, SymbolsOrErr.takeError());
  Symbols = std::move(*SymbolsOrErr);
}

499

The error should not be hit. I change to cantFail , thanks

756

thanks for explain.

765–770

I've added "may" before "contain", on the assumption that an AIX big archive with only 32-bit members won't contain a 64-bit symbol table.

Yes, AIX big archive may only has 32-bit global symbol table. thanks

875–876

there are same. the "GlobSymOffset" is the member of class "BigArchive"

    char GlobSymOffset[20];                  ///< Offset to global symbol table.
    char
        GlobSym64Offset[20]; ///< Offset global symbol table for 64-bit objects
```.

[stephenpeckham]

llvm/lib/Object/ArchiveWriter.cpp

904–905

No need to check NewMembers.size(). GlobalSymbolOffset will be 0 if there are no members.

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

904–905

agree. thanks, I will modify it.

[stephenpeckham]

All issues have been addressed

llvm/include/llvm/Object/Archive.h

struct FixLenHdr {
     char FirstChildOffset[20]; ///< Offset to first archive member.
     char LastChildOffset[20];  ///< Offset to last archive member.
     char FreeOffset[20];       ///< Offset to first mem on free list.
   };
 
   const FixLenHdr *ArFixLenHdr;
   uint64_t FirstChildOffset = 0;
   uint64_t LastChildOffset = 0;
+  SmallString<0> GlobalSymbolTableBuf;
 
 public:
   BigArchive(MemoryBufferRef Source, Error &Err);
   uint64_t getFirstChildOffset() const override { return FirstChildOffset; }
   uint64_t getLastChildOffset() const { return LastChildOffset; }
   bool isEmpty() const override {
     return Data.getBufferSize() == sizeof(FixLenHdr);
   };
 };
 
 } // end namespace object
 } // end namespace llvm
 
 #endif // LLVM_OBJECT_ARCHIVE_H

llvm/lib/Object/Archive.cpp

 #include "llvm/Object/Archive.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Support/Chrono.h"
 #include "llvm/Support/Endian.h"
+#include "llvm/Support/EndianStream.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"

 
 // Returns true if archive file contains no member file.
 bool Archive::isEmpty() const {
   return Data.getBufferSize() == getArchiveMagicLen();
 }
 
 bool Archive::hasSymbolTable() const { return !SymbolTable.empty(); }
 
 BigArchive::BigArchive(MemoryBufferRef Source, Error &Err)
     : Archive(Source, Err) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   StringRef Buffer = Data.getBuffer();
   ArFixLenHdr = reinterpret_cast<const FixLenHdr *>(Buffer.data());
 
   StringRef RawOffset = getFieldRawString(ArFixLenHdr->FirstChildOffset);
-  if (RawOffset.getAsInteger(10, FirstChildOffset))
-    // TODO: Out-of-line.
+  if (RawOffset.getAsInteger(10, FirstChildOffset)) {
     Err = malformedError("malformed AIX big archive: first member offset \"" +
                          RawOffset + "\" is not a number");
+    return;
+  }
 
   RawOffset = getFieldRawString(ArFixLenHdr->LastChildOffset);
-  if (RawOffset.getAsInteger(10, LastChildOffset))
-    // TODO: Out-of-line.
+  if (RawOffset.getAsInteger(10, LastChildOffset)) {
     Err = malformedError("malformed AIX big archive: last member offset \"" +
                          RawOffset + "\" is not a number");
+    return;
+  }
 
-  // Calculate the global symbol table.
-  uint64_t GlobSymOffset = 0;
+  uint64_t GlobSym32Offset = 0;
   RawOffset = getFieldRawString(ArFixLenHdr->GlobSymOffset);
-  if (RawOffset.getAsInteger(10, GlobSymOffset))
-    // TODO: add test case.
-    Err = malformedError(
-        "malformed AIX big archive: global symbol table offset \"" + RawOffset +
-        "\" is not a number");
+  if (RawOffset.getAsInteger(10, GlobSym32Offset)) {
+    Err = malformedError("malformed AIX big archive: global symbol table "
+                         "offset of 32-bits members \"" +
+                         RawOffset + "\" is not a number");
+    return;
+  }
 
-  if (Err)
+  uint64_t GlobSym64Offset = 0;
+  RawOffset = getFieldRawString(ArFixLenHdr->GlobSym64Offset);
+  if (RawOffset.getAsInteger(10, GlobSym64Offset)) {
+    Err = malformedError("malformed AIX big archive: global symbol table "
+                         "offset of 64-bits members\"" +
+                         RawOffset + "\" is not a number");
     return;
+  }
 
-  if (GlobSymOffset > 0) {
+  const char *GlobSym32TblLoc = nullptr;
+  const char *GlobSym64TblLoc = nullptr;
+  uint64_t GlobSym32Size = 0;
+  uint64_t GlobSym64Size = 0;
+
+  auto GetGlobSymTblLocAndSize = [&](uint64_t GlobalSymOffset,
+                                     const char *&GlobSymTblLoc, uint64_t &Size,
+                                     const char *BitMessage) {
     uint64_t BufferSize = Data.getBufferSize();
     uint64_t GlobalSymTblContentOffset =
-        GlobSymOffset + sizeof(BigArMemHdrType);
+        GlobalSymOffset + sizeof(BigArMemHdrType);
     if (GlobalSymTblContentOffset > BufferSize) {
-      Err = malformedError("global symbol table header at offset 0x" +
-                           Twine::utohexstr(GlobSymOffset) + " and size 0x" +
+      Err = malformedError(Twine(BitMessage) +
+                           " global symbol table header at offset 0x" +
+                           Twine::utohexstr(GlobalSymOffset) + " and size 0x" +
                            Twine::utohexstr(sizeof(BigArMemHdrType)) +
                            " goes past the end of file");
       return;
     }
 
-    const char *GlobSymTblLoc = Data.getBufferStart() + GlobSymOffset;
+    GlobSymTblLoc = Data.getBufferStart() + GlobalSymOffset;
     const BigArMemHdrType *GlobalSymHdr =
         reinterpret_cast<const BigArMemHdrType *>(GlobSymTblLoc);
     RawOffset = getFieldRawString(GlobalSymHdr->Size);
-    uint64_t Size;
     if (RawOffset.getAsInteger(10, Size)) {
       // TODO: add test case.
-      Err = malformedError(
-          "malformed AIX big archive: global symbol table size \"" + RawOffset +
+      Err = malformedError("malformed AIX big archive: " + Twine(BitMessage) +
+                           " global symbol table size \"" + RawOffset +
                            "\" is not a number");
       return;
     }
+
     if (GlobalSymTblContentOffset + Size > BufferSize) {
-      Err = malformedError("global symbol table content at offset 0x" +
-                           Twine::utohexstr(GlobalSymTblContentOffset) +
-                           " and size 0x" + Twine::utohexstr(Size) +
-                           " goes past the end of file");
+      Err = malformedError(
+          Twine(BitMessage) + " global symbol table content at offset 0x" +
+          Twine::utohexstr(GlobalSymTblContentOffset) + " and size 0x" +
+          Twine::utohexstr(Size) + " goes past the end of file");
+      return;
+    }
+  };
+
+  if (GlobSym32Offset) {
+    GetGlobSymTblLocAndSize(GlobSym32Offset, GlobSym32TblLoc, GlobSym32Size,
+                            "32-bits");
+    if (Err)
       return;
-    }
+
+  if (GlobSym64Offset) {
+    GetGlobSymTblLocAndSize(GlobSym64Offset, GlobSym64TblLoc, GlobSym64Size,
+                            "64-bits");
+    if (Err)
+      return;
+  }
+
+  StringRef SymbolTable32;
+  StringRef SymbolTable64;
+  StringRef StringTable32;
+  StringRef StringTable64;
+  StringRef SymbolOffestTable32;
+  StringRef SymbolOffestTable64;
+  uint64_t SymNum32 = 0;
+  uint64_t SymNum64 = 0;
+
+  auto GetGlobalSymbolTableInfo = [](const char *GlobSymTblLoc,
+                                     StringRef &SymbolTable,
+                                     StringRef &StringTable,
+                                     StringRef &SymbolOffestTable,
+                                     uint64_t Size, uint64_t &SymNum) {
     SymbolTable = StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType), Size);
-    unsigned SymNum = getNumberOfSymbols();
+    SymNum = read64be(GlobSymTblLoc + sizeof(BigArMemHdrType));
+    SymbolOffestTable = StringRef(SymbolTable.data() + 8, 8 * SymNum);
     unsigned SymOffsetsSize = 8 * (SymNum + 1);
     uint64_t SymbolTableStringSize = Size - SymOffsetsSize;
     StringTable =
-        StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType) + SymOffsetsSize,
-                  SymbolTableStringSize);
+        StringRef(SymbolTable.data() + SymOffsetsSize, SymbolTableStringSize);
+  };
+
+  if (GlobSym32Offset)
+    GetGlobalSymbolTableInfo(GlobSym32TblLoc, SymbolTable32, StringTable32,
+                             SymbolOffestTable32, GlobSym32Size, SymNum32);
+  if (GlobSym64Offset)
+    GetGlobalSymbolTableInfo(GlobSym64TblLoc, SymbolTable64, StringTable64,
+                             SymbolOffestTable64, GlobSym64Size, SymNum64);
+
+  // In order to let the Archive::Symbol::getNext() work for 32-bit and 64-bit
+  // global symbol table, we need to combine two global symbol table  into one.
+  if (GlobSym64Offset && GlobSym32Offset) {
+    raw_svector_ostream Out(GlobalSymbolTableBuf);
+    write(Out, SymNum32 + SymNum64, support::big);
+    // Combine symbol offset.
+    Out << SymbolOffestTable32;
+    Out << SymbolOffestTable64;
+    // Combine string table.
+    Out << StringTable32;
+    Out << StringTable64;
+    SymbolTable = GlobalSymbolTableBuf;
+    StringTable = StringRef(SymbolTable.begin() + (SymNum32 + SymNum64 + 1) * 8,
+                            StringTable32.size() + StringTable64.size());
+  } else if (GlobSym32Offset) {
+    SymbolTable = SymbolTable32;
+    StringTable = StringTable32;
+  } else if (GlobSym64Offset) {
+    SymbolTable = SymbolTable64;
+    StringTable = StringTable64;
   }
 
   child_iterator I = child_begin(Err, false);
   if (Err)
     return;
   child_iterator E = child_end();
   if (I == E) {
     Err = Error::success();
     return;
   }
   setFirstRegular(*I);
   Err = Error::success();
 }

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/BinaryFormat/Magic.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/Object/Archive.h"
+#include "llvm/Object/COFFImportFile.h"
+#include "llvm/Object/ELFObjectFile.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/TapiFile.h"
+#include "llvm/Object/Wasm.h"
 #include "llvm/Object/XCOFFObjectFile.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;
+using namespace llvm::object;
 
 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 =
static uint64_t computeSymbolTableSize(object::Archive::Kind Kind,
   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) {
+                                   uint64_t PrevMemberOffset = 0,
+                                   uint64_t NextMemberOffset = 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);
+    printBigArchiveMemberHeader(Out, "", now(Deterministic), 0, 0, 0, Size,
+                                PrevMemberOffset, NextMemberOffset);
   } else {
     const char *Name = is64BitKind(Kind) ? "/SYM64" : "";
     printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size);
   }
 }
 
+static bool is64BitSymbolicFile(SymbolicFile &Obj) {
+  if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
+    return Triple(IRObj->getTargetTriple()).isArch64Bit();
+  if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
+    return false;
+  if (XCOFFObjectFile *XCOFFObj = dyn_cast<XCOFFObjectFile>(&Obj))
+    return XCOFFObj->is64Bit();
+  if (isa<WasmObjectFile>(Obj))
+    return false;
+  if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
+    return Tapi->is64Bit();
+  if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
+    return MachO->is64Bit();
+  if (ELFObjectFileBase *ElfO = dyn_cast<ELFObjectFileBase>(&Obj))
+    return ElfO->getBytesInAddress() == 8;
+
+  // The is64BitSymbolicFile() in the llvm-ar.cpp will be run before this
+  // function. If there is unsupported file format, it will be fail at that
+  // function first.
+  llvm_unreachable("unsupported file format");
+}
+
+static Expected<std::unique_ptr<SymbolicFile>>
+getSymbolFile(MemoryBufferRef Buf, LLVMContext &Context) {
+  std::unique_ptr<object::SymbolicFile> Obj;
+  const file_magic Type = identify_magic(Buf.getBuffer());
+  // Treat non symbolic file types as nullptr.
+  if (!object::SymbolicFile::isSymbolicFile(Type, &Context))
+    return nullptr;
+  if (Type == file_magic::bitcode) {
+    auto ObjOrErr = object::SymbolicFile::createSymbolicFile(
+        Buf, file_magic::bitcode, &Context);
+    if (!ObjOrErr)
+      return ObjOrErr.takeError();
+    return std::move(*ObjOrErr);
+  } else {
+    auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf);
+    if (!ObjOrErr)
+      return ObjOrErr.takeError();
+    return std::move(*ObjOrErr);
+  }
+}
+
+static Expected<bool> is64BitSymbolicFile(const StringRef &ObjStringRef) {
+  MemoryBufferRef ObjMbf(ObjStringRef, "");
+  // In the scenario when LLVMContext is populated SymbolicFile will contain a
+  // reference to it, thus SymbolicFile should be destroyed first.
+  LLVMContext Context;
+  Expected<std::unique_ptr<SymbolicFile>> ObjOrErr =
+      getSymbolFile(ObjMbf, Context);
+  if (!ObjOrErr)
+    return ObjOrErr.takeError();
+
+  // Treated non symbolic file types as false.
+  if (!*ObjOrErr)
+    return false;
+
+  return is64BitSymbolicFile(*(*ObjOrErr));
+}
+
 static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
                              bool Deterministic, ArrayRef<MemberData> Members,
-                             StringRef StringTable,
-                             uint64_t PrevMemberOffset = 0) {
+                             StringRef StringTable, unsigned NumSyms,
+                             uint64_t PrevMemberOffset = 0,
+                             uint64_t NextMemberOffset = 0,
+                             bool Is64Bit = false) {
   // 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, PrevMemberOffset);
+  uint64_t Size =
+      computeSymbolTableSize(Kind, NumSyms, OffsetSize, StringTable, &Pad);
+  writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset,
+                         NextMemberOffset);
 
   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) {
+    if (isAIXBigArchive(Kind)) {
+      Expected<bool> Is64BitOrErr = is64BitSymbolicFile(M.Data);
+      // If there is an error, the error will be emit when 'computeMemberData'
+      // call 'getSymbol' function, we use consumeError here.
+      if (!Is64BitOrErr)
+        consumeError(Is64BitOrErr.takeError());
+      if (*Is64BitOrErr != Is64Bit) {
+        Pos += M.Header.size() + M.Data.size() + M.Padding.size();
+        continue;
+      }
+    }
+
     for (unsigned StringOffset : M.Symbols) {
       if (isBSDLike(Kind))
         printNBits(Out, Kind, StringOffset);
       printNBits(Out, Kind, Pos); // member offset
     }
     Pos += M.Header.size() + M.Data.size() + M.Padding.size();
   }
 
   if (isBSDLike(Kind))
     // byte count of the string table
     printNBits(Out, Kind, StringTable.size());
   Out << StringTable;
 
   while (Pad--)
     Out.write(uint8_t(0));
 }
 
 static Expected<std::vector<unsigned>>
 getSymbols(MemoryBufferRef Buf, raw_ostream &SymNames, 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());
-  // Treat unsupported file types as having no symbols.
-  if (!object::SymbolicFile::isSymbolicFile(Type, &Context))
-    return Ret;
-  if (Type == file_magic::bitcode) {
-    auto ObjOrErr = object::SymbolicFile::createSymbolicFile(
-        Buf, file_magic::bitcode, &Context);
-    if (!ObjOrErr)
-      return ObjOrErr.takeError();
-    Obj = std::move(*ObjOrErr);
-  } else {
-    auto ObjOrErr = object::SymbolicFile::createSymbolicFile(Buf);
-    if (!ObjOrErr)
-      return ObjOrErr.takeError();
-    Obj = std::move(*ObjOrErr);
-  }
+  std::vector<unsigned> Ret;
+  Expected<std::unique_ptr<SymbolicFile>> ObjOrErr =
+      getSymbolFile(Buf, Context);
+
+  // If the member is not a symbolic file, treated as no symbol.
+  if (!*ObjOrErr)
+    return Ret;
+
+  std::unique_ptr<object::SymbolicFile> Obj = std::move(*ObjOrErr);
 
   HasObject = true;
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))
       continue;
     Ret.push_back(SymNames.tell());
     if (Error E = S.printName(SymNames))
       return std::move(E);
static Error writeArchiveToStream(raw_ostream &Out,
   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.
   uint64_t LastMemberEndOffset =
       isAIXBigArchive(Kind) ? sizeof(object::BigArchive::FixLenHdr) : 8;
   uint64_t LastMemberHeaderOffset = LastMemberEndOffset;
   uint64_t NumSyms = 0;
+  uint64_t NumSyms32 = 0; // Store symbol number of 32-bits member files.
+
   for (const auto &M : Data) {
     // Record the start of the member's offset
     LastMemberHeaderOffset = LastMemberEndOffset;
     // Account for the size of each part associated with the member.
     LastMemberEndOffset += M.Header.size() + M.Data.size() + M.Padding.size();
     NumSyms += M.Symbols.size();
+
+    // In AIX OS, the big archive file contains two global symbol tables. The
+    // first global symbol table locates 32-bit file members that define global
+    // symbols; the second global symbol table does the same for 64-bit file
+    // members. A big archive can has 32-bit and 64-bit file members, we need to
+    // know the symbol number of 32-bit global symbol table and symbol number of
+    // 64-bit global table.
+    if (isAIXBigArchive(Kind) && WriteSymtab) {
+      Expected<bool> Is64BitOrErr = is64BitSymbolicFile(M.Data);
+      if (Error E = Is64BitOrErr.takeError())
+        return E;
+
+      if (!*Is64BitOrErr)
+        NumSyms32 += M.Symbols.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 =
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);
+      writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf, NumSyms);
     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;
for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) {
                              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)
+    SmallString<0> SymNamesBuf32;
+    SmallString<0> SymNamesBuf64;
+    raw_svector_ostream SymNames32(SymNamesBuf32);
+    raw_svector_ostream SymNames64(SymNamesBuf64);
+
+    if (WriteSymtab && NumSyms)
+      // Generate the 32-bits object member symbol name string and 64-bits' one.
+      for (const NewArchiveMember &M : NewMembers) {
+        MemoryBufferRef Buf = M.Buf->getMemBufferRef();
+        Expected<bool> Is64BitOrErr = is64BitSymbolicFile(Buf.getBuffer());
+        if (!Is64BitOrErr)
+          consumeError(Is64BitOrErr.takeError());
+
+        bool HasObject;
+        Expected<std::vector<unsigned>> SymbolsOrErr =
+            getSymbols(Buf, *Is64BitOrErr ? SymNames64 : SymNames32, HasObject);
+        if (!SymbolsOrErr)
+          return SymbolsOrErr.takeError();
+      }
+
+    // In AIX OS, The 'GlobSymOffset' field in the fixed-length header contains
+    // the offset to the 32-bit global symbol table, and the 'GlobSym64Offset'
+    // contains the offset to the 64-bit global symbol table.
+    uint64_t GlobalSymbolOffset =
+        (WriteSymtab && NumSyms32 > 0)
             ? LastMemberEndOffset +
                   alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2)
             : 0;
 
+    uint64_t GlobalSymbolOffset64 = 0;
+    uint64_t NumSyms64 = NumSyms - NumSyms32;
+    if (WriteSymtab && NumSyms64 > 0) {
+      if (GlobalSymbolOffset == 0)
+        GlobalSymbolOffset64 =
+            LastMemberEndOffset +
+            alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2);
+      else
+        // If there is global symbol table for 32-bit member file,
+        // the 64 bit global symbol table is after for 32-bit one.
+        GlobalSymbolOffset64 =
+            GlobalSymbolOffset + sizeof(object::BigArMemHdrType) +
+            (NumSyms32 + 1) * 8 + alignTo(SymNamesBuf32.size(), 2);
+    }
+
     // 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, GlobalSymbolOffset64, 20);
     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
+                                  GlobalSymbolOffset ? GlobalSymbolOffset
+                                                     : GlobalSymbolOffset64);
+      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);
+      if (WriteSymtab) {
+        // Write global table for 32-bit file members.
+        if (NumSyms32 > 0)
+          writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf32,
+                           NumSyms32, LastMemberEndOffset,
+                           GlobalSymbolOffset64);
+        // Write global table for 64-bit file members.
+        if (NumSyms64 > 0) {
+          // Align the 32-bit global symbol table.
+          if (SymNamesBuf32.size() % 2)
+            Out.write(uint8_t(0));
+
+          writeSymbolTable(
+              Out, Kind, Deterministic, Data, SymNamesBuf64, NumSyms64,
+              GlobalSymbolOffset ? GlobalSymbolOffset : LastMemberEndOffset, 0,
+              true);
+        }
+      }
     }
   }
   Out.flush();
   return Error::success();
 }
 
 Error writeArchive(StringRef ArcName, ArrayRef<NewArchiveMember> NewMembers,
                    bool WriteSymtab, object::Archive::Kind Kind,

llvm/test/Object/bigarchive-malformed-global-symbol-table

+## Test malformed global symbal table of big archive.
+
+# RUN: rm -rf %t && mkdir %t && cd %t
+# RUN: yaml2obj -DFLAG=0x1DF %s -o t32.o
+# RUN: yaml2obj -DFLAG=0x1F7 %s -o t64.o
+# RUN: llvm-ar q t.a t32.o t64.o
+
+# RUN: cp t.a t32_1.a
+# RUN: cp t.a t32_2.a
+# RUN: cp t.a t64_1.a
+# RUN: cp t.a t64_2.a
+
+## Truncate the file to end before the 32-bits global symbol table header ends.
+# RUN: %python -c "with open('t32_1.a', 'r+b') as input: input.truncate(856)"
+## Truncate the file to end before the 32-bits global symbol table ends.
+# RUN: %python -c "with open('t32_2.a', 'r+b') as input: input.truncate(995)"
+
+# RUN: not llvm-ar t t32_1.a 2>&1 | FileCheck -DFILE=t32_1.a --check-prefixes=HEADER32 %s
+# RUN: not llvm-ar t t32_2.a 2>&1 | FileCheck -DFILE=t32_2.a --check-prefixes=CONTENT32 %s
+
+# HEADER32:  error: unable to load '[[FILE]]': truncated or malformed archive (32-bits global symbol table header at offset 0x34e and size 0x72 goes past the end of file)
+# CONTENT32: error: unable to load '[[FILE]]': truncated or malformed archive (32-bits global symbol table content at offset 0x3c0 and size 0x2b goes past the end of file)
+
+## Truncate the file to end before the 64-bits global symbol table header ends.
+# RUN: %python -c "with open('t64_1.a', 'r+b') as input: input.truncate(1014)"
+## Truncate the file to end before the 64-bits global symbol table ends.
+# RUN: %python -c "with open('t64_2.a', 'r+b') as input: input.truncate(1096)"
+
+# RUN: not llvm-ar t t64_1.a 2>&1 | FileCheck -DFILE=t64_1.a --check-prefixes=HEADER64 %s
+# RUN: not llvm-ar t t64_2.a 2>&1 | FileCheck -DFILE=t64_2.a --check-prefixes=CONTENT64 %s
+
+# HEADER64:  error: unable to load '[[FILE]]': truncated or malformed archive (64-bits global symbol table header at offset 0x3ec and size 0x72 goes past the end of file)
+# CONTENT64: error: unable to load '[[FILE]]': truncated or malformed archive (64-bits global symbol table header at offset 0x3ec and size 0x72 goes past the end of file) 
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       [[FLAG]]
+Sections:
+  - Name:            .data
+    Flags:           [ STYP_DATA ]
+Symbols:
+  - Name:            export_protected_var_[[FLAG]]
+    Section:         .data
+    Type:            0x4000
+    StorageClass:    C_EXT
+    AuxEntries:
+     - Type:                   AUX_CSECT
+       SymbolAlignmentAndType: 0x09
+       StorageMappingClass:    XMC_RW

llvm/test/Object/bigarchive-malformed-header.test

+## Test malformed big archive file in Fixed-Length header field. 
+
+# RUN: echo    "<bigaf>" >  %t_mal_firstchild.a
+# RUN: echo -n "0                   0                   0                   1i28                0                   0                   " >> %t_mal_firstchild.a
+# RUN: not llvm-ar tv %t_mal_firstchild.a 2>&1 | FileCheck %s -DFILE=%t_mal_firstchild.a --check-prefixes=FIRST
+
+# FIRST: llvm-ar: error: unable to load '[[FILE]]': truncated or malformed archive (malformed AIX big archive: first member offset "1i28" is not a number)
+
+# RUN:  echo    "<bigaf>" >  %t_mal_lastchild.a
+# RUN: echo -n "0                   0                   0                   0                   1i28                0                   " >> %t_mal_lastchild.a
+# RUN: not llvm-ar tv %t_mal_lastchild.a 2>&1 | FileCheck %s -DFILE=%t_mal_lastchild.a --check-prefixes=LAST
+
+# LAST: llvm-ar: error: unable to load '[[FILE]]': truncated or malformed archive (malformed AIX big archive: last member offset "1i28" is not a number) 
+  
+# RUN: echo    "<bigaf>" >  %t_mal_globalsym.a
+# RUN: echo -n "0                   1i28                0                   0                   0                   0                   " >> %t_mal_globalsym.a
+# RUN: not llvm-ar tv %t_mal_globalsym.a 2>&1 | FileCheck %s -DFILE=%t_mal_globalsym.a --check-prefixes=GLOBOFFSET
+
+# GLOBOFFSET: llvm-ar: error: unable to load '[[FILE]]': truncated or malformed archive (malformed AIX big archive: global symbol table offset of 32-bits members "1i28" is not a number)
+ 
+# RUN: echo    "<bigaf>" >  %t_mal_globalsym64.a
+# RUN: echo -n "0                   0                   1i28                0                   0                   0                   " >> %t_mal_globalsym64.a
+# RUN: not llvm-ar tv %t_mal_globalsym64.a 2>&1 | FileCheck %s -DFILE=%t_mal_globalsym64.a --check-prefixes=GLOB64OFFSET
+
+# GLOB64OFFSET: llvm-ar: error: unable to load '[[FILE]]': truncated or malformed archive (malformed AIX big archive: global symbol table offset of 64-bits members"1i28" is not a number) 

llvm/test/Object/bigarchive-symboltable.test

+## Test global symbal table of big archive.
+
+# RUN: rm -rf %t && mkdir %t && cd %t
+# RUN: yaml2obj --docnum=1 -DFLAG=0x1DF %s -o t32_1.o
+# RUN: yaml2obj --docnum=1 -DFLAG=0x1F7 %s -o t64_1.o
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1DF %s -o t32_2.o
+# RUN: yaml2obj --docnum=2 -DFLAG=0x1F7 %s -o t64_2.o
+
+## Test printing a big archive which only has 32-bits symbol names
+# RUN: llvm-ar q t32.a t32_1.o t32_2.o
+# RUN: llvm-nm --print-armap t32.a 2>&1 | FileCheck --check-prefixes=GLOB32 %s
+
+## Test printing a big archive which only has 64-bits symbol names
+# RUN: llvm-ar q t64.a t64_1.o t64_2.o
+# RUN: llvm-nm --print-armap t64.a 2>&1 | FileCheck --check-prefixes=GLOB64 %s
+
+## Test printing all 32-bits symbol names first and then 64-bits
+# RUN: llvm-ar q t32_64_all.a t32_1.o t64_1.o t32_2.o t64_2.o
+# RUN: llvm-ar q t32_64_1.a t32_1.o t64_1.o
+
+# RUN: llvm-nm --print-armap t32_64_all.a 2>&1 | FileCheck --check-prefixes=GLOB32,GLOB64 %s
+# RUN: llvm-nm --print-armap t32_64_1.a 2>&1 | FileCheck --check-prefixes=GLOB1 %s
+
+#GLOB32:      var_0x1DF in t32_1.o
+#GLOB32-NEXT: array_0x1DF in t32_1.o
+#GLOB32-NEXT: func_0x1DF in t32_2.o
+#GLOB32-NEXT: bar_0x1DF in t32_2.o
+
+#GLOB64:      var_0x1F7 in t64_1.o
+#GLOB64-NEXT: array_0x1F7 in t64_1.o
+#GLOB64-NEXT: func_0x1F7 in t64_2.o
+#GLOB64-NEXT: bar_0x1F7 in t64_2.o
+
+#GLOB1:      var_0x1DF in t32_1.o
+#GLOB1-NEXT: array_0x1DF in t32_1.o
+#GLOB1-NEXT: var_0x1F7 in t64_1.o
+#GLOB1-NEXT: array_0x1F7 in t64_1.o
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       [[FLAG]]
+Sections:
+  - Name:            .data
+    Flags:           [ STYP_DATA ]
+Symbols:
+  - Name:            var_[[FLAG]]
+    Section:         .data
+    Type:            0x4000
+    StorageClass:    C_EXT
+    AuxEntries:
+     - Type:                   AUX_CSECT
+       SymbolAlignmentAndType: 0x09
+       StorageMappingClass:    XMC_RW
+  - Name:            array_[[FLAG]]
+    Section:         .data
+    Type:            0x4000
+    StorageClass:    C_EXT
+    AuxEntries:
+     - Type:                   AUX_CSECT
+       SymbolAlignmentAndType: 0x09
+       StorageMappingClass:    XMC_RW
+
+--- !XCOFF
+FileHeader:
+  MagicNumber:       [[FLAG]]
+Sections:
+  - Name:            .text
+    Flags:           [ STYP_DATA ]
+Symbols:
+  - Name:            func_[[FLAG]]
+    Section:         .text
+    Type:            0x4000
+    StorageClass:    C_EXT
+    AuxEntries:
+     - Type:                   AUX_CSECT
+       SymbolAlignmentAndType: 0x09
+       StorageMappingClass:    XMC_PR
+  - Name:            bar_[[FLAG]]
+    Section:         .text
+    Type:            0x4000
+    StorageClass:    C_EXT
+    AuxEntries:
+     - Type:                   AUX_CSECT
+       SymbolAlignmentAndType: 0x09
+       StorageMappingClass:    XMC_PR

llvm/test/tools/llvm-ar/malformed-global-symbol-table-bigarchive.test

-## Test malformed global symbal table of big archive.
-
-# RUN: rm -rf %t && mkdir %t && cd %t
-# RUN: yaml2obj %s -o t.o
-# RUN: llvm-ar q t.a t.o
-# RUN: cp t.a t2.a
-
-## Truncate the file to end before the global symbol table header ends.
-# RUN: %python -c "with open('t.a', 'r+b') as input: input.truncate(560)"
-## Truncate the file to end before the global symbol table ends.
-# RUN: %python -c "with open('t2.a', 'r+b') as input: input.truncate(656)"
-
-# RUN: not llvm-ar t t.a 2>&1 | FileCheck -DFILE=t.a %s
-# RUN: not llvm-ar t t2.a 2>&1 | FileCheck -DFILE=t2.a --check-prefixes=CHECK2 %s
-
-# CHECK:  error: unable to load '[[FILE]]': truncated or malformed archive (global symbol table header at offset 0x20e and size 0x72 goes past the end of file)
-# CHECK2: error: unable to load '[[FILE]]': truncated or malformed archive (global symbol table content at offset 0x280 and size 0x25 goes past the end of file)
-
---- !XCOFF
-FileHeader:
-  MagicNumber:       0x1DF
-Sections:
-  - Name:            .data
-    Flags:           [ STYP_DATA ]
-Symbols:
-  - Name:            export_protected_var
-    Section:         .data
-    Type:            0x4000
-    StorageClass:    C_EXT
-    AuxEntries:
-     - Type:                   AUX_CSECT
-       SymbolAlignmentAndType: 0x09
-       StorageMappingClass:    XMC_RW