[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

413

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

1358

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.

1369

1387–1389

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.

1407

1414

1415

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;
};

1428

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

llvm/lib/Object/ArchiveWriter.cpp

470

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

413

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

470

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

413

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

1358

OK, I will do it.

1415

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

413

See my comments elsewhere about naming.

llvm/lib/Object/Archive.cpp

1280

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.

1299

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.

1319

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.

1416–1418

1429

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

455

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

456

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

458

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

475

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?

485

543–544

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?

546

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.

645

899

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").

908–913

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.

1049

1063–1064

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

1067–1068

1099

1104–1105

I think this comment would be a little clearer.

1107

The style elsewhere uses the suggested edit.

1110

[DiggerLin]

address comments, thanks James.

[DiggerLin]

llvm/include/llvm/Object/Archive.h

413

thanks

llvm/lib/Object/Archive.cpp

1299

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

475

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

543–544

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);
}

546

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

899

thanks for explain.

908–913

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

1063–1064

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

1064–1065

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

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

1064–1065

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;
+  std::string MergedGlobalSymtabBuf;
 
 public:
   BigArchive(MemoryBufferRef Source, Error &Err);
   uint64_t getFirstChildOffset() const override { return FirstChildOffset; }
   uint64_t getLastChildOffset() const { return LastChildOffset; }
   bool isEmpty() const override { return getFirstChildOffset() == 0; }
 };
 
 } // 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/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Host.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(); }
 
+static Error getGlobalSymtabLocAndSize(const MemoryBufferRef &Data,
+                                       uint64_t GlobalSymtabOffset,
+                                       const char *&GlobalSymtabLoc,
+                                       uint64_t &Size, const char *BitMessage) {
+  uint64_t BufferSize = Data.getBufferSize();
+  uint64_t GlobalSymtabContentOffset =
+      GlobalSymtabOffset + sizeof(BigArMemHdrType);
+  if (GlobalSymtabContentOffset > BufferSize)
+    return malformedError(
+        Twine(BitMessage) + " global symbol table header at offset 0x" +
+        Twine::utohexstr(GlobalSymtabOffset) + " and size 0x" +
+        Twine::utohexstr(sizeof(BigArMemHdrType)) +
+        " goes past the end of file");
+
+  GlobalSymtabLoc = Data.getBufferStart() + GlobalSymtabOffset;
+  const BigArMemHdrType *GlobalSymHdr =
+      reinterpret_cast<const BigArMemHdrType *>(GlobalSymtabLoc);
+  StringRef RawOffset = getFieldRawString(GlobalSymHdr->Size);
+  if (RawOffset.getAsInteger(10, Size))
+    return malformedError(Twine(BitMessage) + " global symbol table size \"" +
+                          RawOffset + "\" is not a number");
+
+  if (GlobalSymtabContentOffset + Size > BufferSize)
+    return malformedError(
+        Twine(BitMessage) + " global symbol table content at offset 0x" +
+        Twine::utohexstr(GlobalSymtabContentOffset) + " and size 0x" +
+        Twine::utohexstr(Size) + " goes past the end of file");
+
+  return Error::success();
+}
+
+struct GlobalSymtabInfo {
+  uint64_t SymNum;
+  StringRef SymbolTable;
+  StringRef SymbolOffsetTable;
+  StringRef StringTable;
+};
+
+static void
+appendGlobalSymbolTableInfo(SmallVector<GlobalSymtabInfo> &SymtabInfos,
+                            const char *GlobalSymtabLoc, uint64_t Size) {
+  // In a big archive, a global symbol table contains the following information:
+  // - The number of symbols.
+  // - The array of offsets into the archive file. The length is eight
+  //   times the number of symbols.
+  // - The name-string table. The size is:
+  //   Size-(8*(the number of symbols + 1)).
+
+  StringRef SymbolTable =
+      StringRef(GlobalSymtabLoc + sizeof(BigArMemHdrType), Size);
+  uint64_t SymNum = read64be(GlobalSymtabLoc + sizeof(BigArMemHdrType));
+  StringRef SymbolOffsetTable = StringRef(SymbolTable.data() + 8, 8 * SymNum);
+  unsigned SymOffsetsSize = 8 * (SymNum + 1);
+  uint64_t SymbolTableStringSize = Size - SymOffsetsSize;
+  StringRef StringTable =
+      StringRef(SymbolTable.data() + SymOffsetsSize, SymbolTableStringSize);
+  SymtabInfos.push_back({SymNum, SymbolTable, SymbolOffsetTable, StringTable});
+}
+
 BigArchive::BigArchive(MemoryBufferRef Source, Error &Err)
     : Archive(Source, Err) {
   ErrorAsOutParameter ErrAsOutParam(&Err);
   StringRef Buffer = Data.getBuffer();
   ArFixLenHdr = reinterpret_cast<const FixLenHdr *>(Buffer.data());
   uint64_t BufferSize = Data.getBufferSize();
 
   if (BufferSize < sizeof(FixLenHdr)) {
     Err = malformedError("malformed AIX big archive: incomplete fixed length "
                          "header, the archive is only" +
                          Twine(BufferSize) + " byte(s)");
     return;
   }
 
   StringRef RawOffset = getFieldRawString(ArFixLenHdr->FirstChildOffset);
   if (RawOffset.getAsInteger(10, FirstChildOffset))
     // TODO: Out-of-line.
     Err = malformedError("malformed AIX big archive: first member offset \"" +
                          RawOffset + "\" is not a number");
 
   RawOffset = getFieldRawString(ArFixLenHdr->LastChildOffset);
   if (RawOffset.getAsInteger(10, LastChildOffset))
     // TODO: Out-of-line.
     Err = malformedError("malformed AIX big archive: last member offset \"" +
                          RawOffset + "\" is not a number");
 
-  // Calculate the global symbol table.
-  uint64_t GlobSymOffset = 0;
+  uint64_t GlobSymtab32Offset = 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 (Err)
+  if (RawOffset.getAsInteger(10, GlobSymtab32Offset)) {
+    Err = malformedError("global symbol table "
+                         "offset of 32-bit members \"" +
+                         RawOffset + "\" is not a number");
     return;
+  }
 
-  if (GlobSymOffset > 0) {
-    uint64_t GlobalSymTblContentOffset =
-        GlobSymOffset + sizeof(BigArMemHdrType);
-    if (GlobalSymTblContentOffset > BufferSize) {
-      Err = malformedError("global symbol table header at offset 0x" +
-                           Twine::utohexstr(GlobSymOffset) + " and size 0x" +
-                           Twine::utohexstr(sizeof(BigArMemHdrType)) +
-                           " goes past the end of file");
-      return;
-    }
+  uint64_t GlobSymtab64Offset = 0;
+  RawOffset = getFieldRawString(ArFixLenHdr->GlobSym64Offset);
+  if (RawOffset.getAsInteger(10, GlobSymtab64Offset)) {
+    Err = malformedError("global symbol table "
+                         "offset of 64-bit members\"" +
+                         RawOffset + "\" is not a number");
 
-    const char *GlobSymTblLoc = Data.getBufferStart() + GlobSymOffset;
-    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 +
-          "\" is not a number");
+  const char *GlobSymtab32Loc = nullptr;
+  const char *GlobSymtab64Loc = nullptr;
+  uint64_t GlobSymtab32Size = 0;
+  uint64_t GlobSymtab64Size = 0;
+  const MemoryBufferRef &MemBuffRef = getMemoryBufferRef();
+
+  if (GlobSymtab32Offset) {
+    Err =
+        getGlobalSymtabLocAndSize(MemBuffRef, GlobSymtab32Offset,
+                                  GlobSymtab32Loc, GlobSymtab32Size, "32-bit");
+    if (Err)
       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");
+
+  if (GlobSymtab64Offset) {
+    Err =
+        getGlobalSymtabLocAndSize(MemBuffRef, GlobSymtab64Offset,
+                                  GlobSymtab64Loc, GlobSymtab64Size, "64-bit");
+    if (Err)
       return;
-    }
-    SymbolTable = StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType), Size);
-    unsigned SymNum = getNumberOfSymbols();
-    unsigned SymOffsetsSize = 8 * (SymNum + 1);
-    uint64_t SymbolTableStringSize = Size - SymOffsetsSize;
-    StringTable =
-        StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType) + SymOffsetsSize,
-                  SymbolTableStringSize);
+
+  SmallVector<GlobalSymtabInfo> SymtabInfos;
+
+  if (GlobSymtab32Offset)
+    appendGlobalSymbolTableInfo(SymtabInfos, GlobSymtab32Loc, GlobSymtab32Size);
+  if (GlobSymtab64Offset)
+    appendGlobalSymbolTableInfo(SymtabInfos, GlobSymtab64Loc, GlobSymtab64Size);
+
+  if (SymtabInfos.size() == 1) {
+    SymbolTable = SymtabInfos[0].SymbolTable;
+    StringTable = SymtabInfos[0].StringTable;
+  } else if (SymtabInfos.size() == 2) {
+    // In order to let the Archive::Symbol::getNext() work for both 32-bit and
+    // 64-bit global symbol tables, we need to merge them into a single table.
+    raw_string_ostream Out(MergedGlobalSymtabBuf);
+    uint64_t SymNum = SymtabInfos[0].SymNum + SymtabInfos[1].SymNum;
+    write(Out, SymNum, support::big);
+    // Merge symbol offset.
+    Out << SymtabInfos[0].SymbolOffsetTable;
+    Out << SymtabInfos[1].SymbolOffsetTable;
+    // Merge string table.
+    Out << SymtabInfos[0].StringTable;
+    Out << SymtabInfos[1].StringTable;
+    SymbolTable = MergedGlobalSymtabBuf;
+    // The size of the symbol offset to the member file is 8 bytes.
+    StringTable = StringRef(SymbolTable.begin() + (SymNum + 1) * 8,
+                            SymtabInfos[0].StringTable.size() +
+                                SymtabInfos[1].StringTable.size());
   }
 
   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

 
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 using namespace llvm;
+using namespace llvm::object;
 
 struct SymMap {
   bool UseECMap;
   std::map<std::string, uint16_t> Map;
   std::map<std::string, uint16_t> ECMap;
 };
 
 NewArchiveMember::NewArchiveMember(MemoryBufferRef BufRef)
static uint64_t computeECSymbolsSize(SymMap &SymMap,
   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 uint64_t computeHeadersSize(object::Archive::Kind Kind,
                                    uint64_t NumMembers,
                                    uint64_t StringMemberSize, uint64_t NumSyms,
                                    uint64_t SymNamesSize, SymMap *SymMap) {
   uint32_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
   uint64_t SymtabSize =
       computeSymbolTableSize(Kind, NumSyms, OffsetSize, SymNamesSize);
   auto computeSymbolTableHeaderSize = [=] {
     SmallString<0> TmpBuf;
     raw_svector_ostream Tmp(TmpBuf);
     writeSymbolTableHeader(Tmp, Kind, true, SymtabSize);
     return TmpBuf.size();
   };
   uint32_t HeaderSize = computeSymbolTableHeaderSize();
   uint64_t Size = strlen("!<arch>\n") + HeaderSize + SymtabSize;
 
   if (SymMap) {
     Size += HeaderSize + computeSymbolMapSize(NumMembers, *SymMap);
     if (SymMap->ECMap.size())
       Size += HeaderSize + computeECSymbolsSize(*SymMap);
   }
 
   return Size + StringMemberSize;
 }
 
+static Expected<std::unique_ptr<SymbolicFile>>
+getSymbolicFile(MemoryBufferRef Buf, LLVMContext &Context) {
+  const file_magic Type = identify_magic(Buf.getBuffer());
+  // Don't attempt to read non-symbolic file types.
+  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 =
+      getSymbolicFile(ObjMbf, Context);
+  if (!ObjOrErr)
+    return ObjOrErr.takeError();
+
+  // Treat non-symbolic file types as not 64-bits.
+  if (!*ObjOrErr)
+    return false;
+
+  return (*ObjOrErr)->is64Bit();
+}
+
 static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
                              bool Deterministic, ArrayRef<MemberData> Members,
                              StringRef StringTable, uint64_t MembersOffset,
-                             uint64_t PrevMemberOffset = 0) {
+                             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) && !isCOFFArchive(Kind))
     return;
 
-  unsigned NumSyms = 0;
-  for (const MemberData &M : Members)
-    NumSyms += M.Symbols.size();
-
   uint64_t OffsetSize = is64BitKind(Kind) ? 8 : 4;
   uint32_t Pad;
   uint64_t Size = computeSymbolTableSize(Kind, NumSyms, OffsetSize,
                                          StringTable.size(), &Pad);
-  writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset);
+  writeSymbolTableHeader(Out, Kind, Deterministic, Size, PrevMemberOffset,
+                         NextMemberOffset);
 
   if (isBSDLike(Kind))
     printNBits(Out, Kind, NumSyms * 2 * OffsetSize);
   else
     printNBits(Out, Kind, NumSyms);
 
   uint64_t Pos = MembersOffset;
   for (const MemberData &M : Members) {
+    if (isAIXBigArchive(Kind)) {
+      Expected<bool> Is64BitOrErr = is64BitSymbolicFile(M.Data);
+      // If there is an error, the error will have been emitted when
+      // 'computeMemberData' called the 'getSymbol' function, so don't need to
+      // handle it here.
+      if (!Is64BitOrErr)
+        cantFail(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();
   }
 
static bool isECObject(object::SymbolicFile &Obj) {
   }
 
   return false;
 }
 
 static Expected<std::vector<unsigned>>
 getSymbols(MemoryBufferRef Buf, uint16_t Index, raw_ostream &SymNames,
            SymMap *SymMap, bool &HasObject) {
-  std::vector<unsigned> Ret;
-
   // In the scenario when LLVMContext is populated SymbolicFile will contain a
   // reference to it, thus SymbolicFile should be destroyed first.
   LLVMContext Context;
-  std::unique_ptr<object::SymbolicFile> Obj;
 
-  const file_magic Type = identify_magic(Buf.getBuffer());
-  // 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 =
+      getSymbolicFile(Buf, Context);
+
+  // If the member is non-symbolic file, treat it as having no symbols.
+  if (!*ObjOrErr)
+    return Ret;
+
+  std::unique_ptr<object::SymbolicFile> Obj = std::move(*ObjOrErr);
 
   std::map<std::string, uint16_t> *Map = nullptr;
   if (SymMap)
     Map = SymMap->UseECMap && isECObject(*Obj) ? &SymMap->ECMap : &SymMap->Map;
   HasObject = true;
   for (const object::BasicSymbolRef &S : Obj->symbols()) {
     if (!isArchiveSymbol(S))
       continue;
StringTableSize = StringTableMember.Header.size() +
                       StringTableMember.Data.size() +
                       StringTableMember.Padding.size();
   }
 
   // We would like to detect if we need to switch to a 64-bit symbol table.
   uint64_t LastMemberEndOffset = 0;
   uint64_t LastMemberHeaderOffset = 0;
   uint64_t NumSyms = 0;
+  uint64_t NumSyms32 = 0; // Store symbol number of 32-bit 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();
+
+    // AIX big archive files may contain 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. As a big archive can have both 32-bit and 64-bit file members,
+    // we need to know the number of symbols in each symbol table individually.
+    if (isAIXBigArchive(Kind) && WriteSymtab) {
+      Expected<bool> Is64BitOrErr = is64BitSymbolicFile(M.Data);
+      if (Error E = Is64BitOrErr.takeError())
+        return E;
+
+      if (!*Is64BitOrErr)
+        NumSyms32 += M.Symbols.size();
+    }
   }
 
   std::optional<uint64_t> HeadersSize;
 
   // The symbol table is put at the end of the big archive file. The symbol
   // table is at the start of the archive file for other archive formats.
   if (WriteSymtab && !is64BitKind(Kind)) {
     // We assume 32-bit offsets to see if 32-bit symbols are possible or not.
static Error writeArchiveToStream(raw_ostream &Out,
 
   if (!isAIXBigArchive(Kind)) {
     if (WriteSymtab) {
       if (!HeadersSize)
         HeadersSize = computeHeadersSize(
             Kind, Data.size(), StringTableSize, NumSyms, SymNamesBuf.size(),
             isCOFFArchive(Kind) ? &SymMap : nullptr);
       writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf,
-                       *HeadersSize);
+                       *HeadersSize, NumSyms);
 
       if (isCOFFArchive(Kind))
         writeSymbolMap(Out, Kind, Deterministic, Data, SymMap, *HeadersSize);
     }
 
     if (StringTableSize)
       Out << StringTableMember.Header << StringTableMember.Data
           << StringTableMember.Padding;
for (size_t I = 0, Size = NewMembers.size(); I != Size; ++I) {
                              alignTo(Member.MemberName.size(), 2);
     }
 
     // AIX member table size.
     uint64_t MemberTableSize = 20 + // Number of members field
                                20 * MemberOffsets.size() +
                                MemberTableNameStrTblSize;
 
+    SmallString<0> SymNamesBuf32;
+    SmallString<0> SymNamesBuf64;
+    raw_svector_ostream SymNames32(SymNamesBuf32);
+    raw_svector_ostream SymNames64(SymNamesBuf64);
+
+    if (WriteSymtab && NumSyms)
+      // Generate the symbol names for the members.
+      for (const NewArchiveMember &M : NewMembers) {
+        MemoryBufferRef Buf = M.Buf->getMemBufferRef();
+        Expected<bool> Is64BitOrErr = is64BitSymbolicFile(Buf.getBuffer());
+        if (!Is64BitOrErr)
+          return Is64BitOrErr.takeError();
+
+        bool HasObject;
+        Expected<std::vector<unsigned>> SymbolsOrErr =
+            getSymbols(Buf, 0, *Is64BitOrErr ? SymNames64 : SymNames32, nullptr,
+                       HasObject);
+        if (!SymbolsOrErr)
+          return SymbolsOrErr.takeError();
+      }
+
+    uint64_t MemberTableEndOffset =
+        LastMemberEndOffset +
+        alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2);
+
+    // 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 && NumSyms > 0)
-            ? LastMemberEndOffset +
-                  alignTo(sizeof(object::BigArMemHdrType) + MemberTableSize, 2)
-            : 0;
+        (WriteSymtab && NumSyms32 > 0) ? MemberTableEndOffset : 0;
+
+    uint64_t GlobalSymbolOffset64 = 0;
+    uint64_t NumSyms64 = NumSyms - NumSyms32;
+    if (WriteSymtab && NumSyms64 > 0) {
+      if (GlobalSymbolOffset == 0)
+        GlobalSymbolOffset64 = MemberTableEndOffset;
+      else
+        // If there is a global symbol table for 32-bit members,
+        // the 64-bit global symbol table is after the 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, GlobalSymbolOffset, 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);
+                                  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,
-                         *HeadersSize, LastMemberEndOffset);
+      if (WriteSymtab) {
+        // Write global symbol table for 32-bit file members.
+        if (GlobalSymbolOffset) {
+          writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf32,
+                           *HeadersSize, NumSyms32, LastMemberEndOffset,
+                           GlobalSymbolOffset64);
+          // Add padding between the symbol tables, if needed.
+          if (GlobalSymbolOffset64 && (SymNamesBuf32.size() % 2))
+            Out << '\0';
+        }
+
+        // Write global symbol table for 64-bit file members.
+        if (GlobalSymbolOffset64)
+          writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf64,
+                           *HeadersSize, 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/Inputs/bitcode-sym32.ll

+target triple = "powerpcle-unknown-linux-gnu"
+
+@C32 = dso_local global i32 5, align 4
+@undef_var32 = external dso_local global i32, align 4
+
+define dso_local i32 @foo32(i32 %i) #0 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, ptr %i.addr, align 4
+  %0 = load i32, ptr %i.addr, align 4
+  %1 = load i32, ptr @undef_var32, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

llvm/test/Object/Inputs/bitcode-sym64.ll

+target triple = "powerpc64le-unknown-linux-gnu"
+
+@C64 = dso_local global i32 5, align 4
+@static_var64 = internal global i32 2, align 4
+
+define dso_local signext i32 @bar64() #0 {
+entry:
+  %0 = load i32, ptr @static_var64, align 4
+  %1 = load i32, ptr @C64, align 4
+  %add = add nsw i32 %0, %1
+  ret i32 %add
+}

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-bit 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-bit 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-bit 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-bit global symbol table content at offset 0x3c0 and size 0x2b goes past the end of file)
+
+## Truncate the file to end before the 64-bit 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-bit 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-bit 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-bit 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_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 (global symbol table offset of 32-bit 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 (global symbol table offset of 64-bit 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
+# RUN: llvm-as -o 32.bc %p/Inputs/bitcode-sym32.ll
+# RUN: llvm-as -o 64.bc %p/Inputs/bitcode-sym64.ll
+
+## Test printing a big archive which only has 32-bits symbol names
+# RUN: llvm-ar q t32.a t32_1.o t32_2.o 32.bc
+# RUN: llvm-nm --print-armap t32.a 2>&1 | FileCheck --check-prefixes=GLOB32,NOGL64 %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 64.bc
+# RUN: llvm-nm --print-armap t64.a 2>&1 | FileCheck --check-prefixes=GLOB64,NOGL32 %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 32.bc 64.bc
+
+# RUN: llvm-nm --print-armap t32_64_all.a 2>&1 | FileCheck --check-prefixes=GLOB32,GLOB64 %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
+#GLOB32-NEXT: foo32 in 32.bc
+#GLOB32-NEXT: C32 in 32.bc 
+
+#NOGL32-NOT: var_0x1DF in t32_1.o
+#NOGL32-NOT:  array_0x1DF in t32_1.o
+#NOGL32-NOT:  func_0x1DF in t32_2.o
+#NOGL32-NOT:  bar_0x1DF in t32_2.o
+#NOGL32-NOT:  foo32 in 32.bc
+#NOGL32-NOT:  C32 in 32.bc
+
+#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
+#GLOB64-NEXT: bar64 in 64.bc
+#GLOB64-NEXT: C64 in 64.bc
+
+#NOGL64-NOT: var_0x1F7 in t64_1.o
+#NOGL64-NOT: array_0x1F7 in t64_1.o
+#NOGL64-NOT: func_0x1F7 in t64_2.o
+#NOGL64-NOT: bar_0x1F7 in t64_2.o
+#NOGL64-NOT: bar64 in 64.bc
+#NOGL64-NOT: C64 in 64.bc
+
+--- !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