[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

1234

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.

1245

1263–1265

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.

1281

1288

1289

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

1302

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

llvm/lib/Object/ArchiveWriter.cpp

419

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

419

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

1234

OK, I will do it.

1289

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.

1290–1292

1303

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

404

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

405

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

407

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

424

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?

434

470–471

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?

473

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.

509

730

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

739–744

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.

835

849–850

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

866–867

914

919–920

I think this comment would be a little clearer.

922

The style elsewhere uses the suggested edit.

925

[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

424

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

470–471

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

473

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

730

thanks for explain.

739–744

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

849–850

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

878–879

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

[DiggerLin]

llvm/lib/Object/ArchiveWriter.cpp

878–879

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 MergedGloSymTblBuf;
 
 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(); }
 
+static Error GetGlobSymTblLocAndSize(const MemoryBufferRef &Data,
+                                     uint64_t GlobalSymOffset,
+                                     const char *&GlobSymTblLoc, uint64_t &Size,
+                                     const char *BitMessage) {
+  uint64_t BufferSize = Data.getBufferSize();
+  uint64_t GlobalSymTblContentOffset =
+      GlobalSymOffset + sizeof(BigArMemHdrType);
+  if (GlobalSymTblContentOffset > BufferSize)
+    return 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");
+
+  GlobSymTblLoc = Data.getBufferStart() + GlobalSymOffset;
+  const BigArMemHdrType *GlobalSymHdr =
+      reinterpret_cast<const BigArMemHdrType *>(GlobSymTblLoc);
+  StringRef RawOffset = getFieldRawString(GlobalSymHdr->Size);
+  if (RawOffset.getAsInteger(10, Size))
+    return malformedError("malformed AIX big archive: " + Twine(BitMessage) +
+                          " global symbol table size \"" + RawOffset +
+                          "\" is not a number");
+
+  if (GlobalSymTblContentOffset + Size > BufferSize)
+    return 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 Error::success();
+}
+
+struct GlobalSymTblInfo {
+  uint64_t SymNum;
+  StringRef SymbolTable;
+  StringRef SymbolOffestTable;
+  StringRef StringTable;
+};
+
+static void GetGlobalSymbolTableInfo(SmallVector<GlobalSymTblInfo> &SymTblInfos,
+                                     const char *GlobSymTblLoc, uint64_t Size) {
+  StringRef SymbolTable =
+      StringRef(GlobSymTblLoc + sizeof(BigArMemHdrType), Size);
+  uint64_t SymNum = read64be(GlobSymTblLoc + sizeof(BigArMemHdrType));
+  StringRef SymbolOffestTable = StringRef(SymbolTable.data() + 8, 8 * SymNum);
+  unsigned SymOffsetsSize = 8 * (SymNum + 1);
+  uint64_t SymbolTableStringSize = Size - SymOffsetsSize;
+  StringRef StringTable =
+      StringRef(SymbolTable.data() + SymOffsetsSize, SymbolTableStringSize);
+  SymTblInfos.push_back({SymNum, SymbolTable, SymbolOffestTable, StringTable});
+}
+
 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.
     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 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 (Err)
+  if (RawOffset.getAsInteger(10, GlobSym32Offset)) {
+    Err = malformedError("malformed AIX big archive: global symbol table "
+                         "offset of 32-bit members \"" +
+                         RawOffset + "\" is not a number");
     return;
+  }
 
-  if (GlobSymOffset > 0) {
-    uint64_t BufferSize = Data.getBufferSize();
-    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 GlobSym64Offset = 0;
+  RawOffset = getFieldRawString(ArFixLenHdr->GlobSym64Offset);
+  if (RawOffset.getAsInteger(10, GlobSym64Offset)) {
+    Err = malformedError("malformed AIX big archive: 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 *GlobSym32TblLoc = nullptr;
+  const char *GlobSym64TblLoc = nullptr;
+  uint64_t GlobSym32Size = 0;
+  uint64_t GlobSym64Size = 0;
+  const MemoryBufferRef &MemBuffRef = getMemoryBufferRef();
+
+  if (GlobSym32Offset) {
+    Err = GetGlobSymTblLocAndSize(MemBuffRef, GlobSym32Offset, GlobSym32TblLoc,
+                                  GlobSym32Size, "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 (GlobSym64Offset) {
+    Err = GetGlobSymTblLocAndSize(MemBuffRef, GlobSym64Offset, GlobSym64TblLoc,
+                                  GlobSym64Size, "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<GlobalSymTblInfo> SymTblInfos;
+
+  if (GlobSym32Offset)
+    GetGlobalSymbolTableInfo(SymTblInfos, GlobSym32TblLoc, GlobSym32Size);
+  if (GlobSym64Offset)
+    GetGlobalSymbolTableInfo(SymTblInfos, GlobSym64TblLoc, GlobSym64Size);
+
+  if (SymTblInfos.size() == 1) {
+    SymbolTable = SymTblInfos[0].SymbolTable;
+    StringTable = SymTblInfos[0].StringTable;
+  } else if (SymTblInfos.size() == 2) {
+    // In order to let the Archive::Symbol::getNext() work for 32-bit and 64-bit
+    // global symbol table, we need to merge two global symbol table  into
+    // one.
+    raw_string_ostream Out(MergedGloSymTblBuf);
+    uint64_t SymNum = SymTblInfos[0].SymNum + SymTblInfos[0].SymNum;
+    write(Out, SymNum, support::big);
+    // Merge symbol offset.
+    Out << SymTblInfos[0].SymbolOffestTable;
+    Out << SymTblInfos[1].SymbolOffestTable;
+    // Merge string table.
+    Out << SymTblInfos[0].StringTable;
+    Out << SymTblInfos[1].StringTable;
+    SymbolTable = MergedGloSymTblBuf;
+    StringTable = StringRef(SymbolTable.begin() + (SymNum + 1) * 8,
+                            SymTblInfos[0].StringTable.size() +
+                                SymTblInfos[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;
 
 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 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 (*ObjOrErr)->is64Bit();
+}
+
 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 (GlobalSymbolOffset) {
+          writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf32,
+                           NumSyms32, LastMemberEndOffset,
+                           GlobalSymbolOffset64);
+          // Align the 32-bit global symbol table for 64-bit global symbol table
+          // if there is.
+          if (GlobalSymbolOffset64 && (SymNamesBuf32.size() % 2))
+            Out.write(uint8_t(0));
+        }
+
+        // Write global table for 64-bit file members.
+        if (GlobalSymbolOffset64)
+          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/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-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_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-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 (malformed AIX big 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