[Object][NFC] Don't insert string table into object members vector.

[jacek]

Summary

Having string table in members vector does not fit later patches in this series. Symbol map needs to refer to objects' offsets, but string table should not be referenced. Also for ARM64EC, the new <ECSYMBOLS> table is inserted after string table.

[mstorsjo]

I presume this is an NFC refactoring too, with no externally observable functional change?

[mstorsjo]

In D143538#4113939, @mstorsjo wrote:

I presume this is an NFC refactoring too, with no externally observable functional change?

Ditto, sorry for commenting without checking properly first.

[jacek]

rebased

[efriedma]

LGTM

[jacek]

Rebased, thanks.

llvm/lib/Object/ArchiveWriter.cpp

if (isBSDLike(Kind)) {
     printBigArchiveMemberHeader(Out, "", now(Deterministic), 0, 0,
                                 0, Size, PrevMemberOffset, 0);
   } else {
     const char *Name = is64BitKind(Kind) ? "/SYM64" : "";
     printGNUSmallMemberHeader(Out, Name, now(Deterministic), 0, 0, 0, Size);
   }
 }
 
-static uint64_t computeHeadersSize(object::Archive::Kind Kind, uint64_t NumSyms,
+static uint64_t computeHeadersSize(object::Archive::Kind Kind,
+                                   uint64_t StringMemberSize, uint64_t NumSyms,
                                    uint64_t SymNamesSize) {
   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();
   };
 
-  return strlen("!<arch>\n") + computeSymbolTableHeaderSize() + SymtabSize;
+  return strlen("!<arch>\n") + computeSymbolTableHeaderSize() + SymtabSize + StringMemberSize;
 }
 
 static void writeSymbolTable(raw_ostream &Out, object::Archive::Kind Kind,
                              bool Deterministic, ArrayRef<MemberData> Members,
                              StringRef StringTable, uint64_t MembersOffset,
                              uint64_t PrevMemberOffset = 0) {
   // We don't write a symbol table on an archive with no members -- except on
   // Darwin, where the linker will abort unless the archive has a symbol table.
static Error writeArchiveToStream(raw_ostream &Out,
 
   Expected<std::vector<MemberData>> DataOrErr =
       computeMemberData(StringTable, SymNames, Kind, Thin, Deterministic,
                         WriteSymtab, NewMembers);
   if (Error E = DataOrErr.takeError())
     return E;
   std::vector<MemberData> &Data = *DataOrErr;
 
-  if (!StringTableBuf.empty() && !isAIXBigArchive(Kind))
-    Data.insert(Data.begin(), computeStringTable(StringTableBuf));
+  uint64_t StringTableSize = 0;
+  MemberData StringTableMember;
+  if (!StringTableBuf.empty() && !isAIXBigArchive(Kind)) {
+    StringTableMember = computeStringTable(StringTableBuf);
+    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;
   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();
   }
 
   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.
-    HeadersSize = computeHeadersSize(Kind, NumSyms, SymNamesBuf.size());
+    HeadersSize =
+        computeHeadersSize(Kind, StringTableSize, NumSyms, SymNamesBuf.size());
 
     // The SYM64 format is used when an archive's member offsets are larger than
     // 32-bits can hold. The need for this shift in format is detected by
     // writeArchive. To test this we need to generate a file with a member that
     // has an offset larger than 32-bits but this demands a very slow test. To
     // speed the test up we use this environment variable to pretend like the
     // cutoff happens before 32-bits and instead happens at some much smaller
     // value.
static Error writeArchiveToStream(raw_ostream &Out,
   else if (isAIXBigArchive(Kind))
     Out << "<bigaf>\n";
   else
     Out << "!<arch>\n";
 
   if (!isAIXBigArchive(Kind)) {
     if (WriteSymtab) {
       if (!HeadersSize)
-        HeadersSize = computeHeadersSize(Kind, NumSyms, SymNamesBuf.size());
+        HeadersSize = computeHeadersSize(Kind, StringTableSize, NumSyms,
+                                         SymNamesBuf.size());
       writeSymbolTable(Out, Kind, Deterministic, Data, SymNamesBuf,
                        *HeadersSize);
     }
+
+    if (StringTableSize)
+      Out << StringTableMember.Header << StringTableMember.Data
+          << StringTableMember.Padding;
+
     for (const MemberData &M : Data)
       Out << M.Header << M.Data << M.Padding;
   } else {
     HeadersSize = sizeof(object::BigArchive::FixLenHdr);
     LastMemberEndOffset += *HeadersSize;
     LastMemberHeaderOffset += *HeadersSize;
 
     // For the big archive (AIX) format, compute a table of member names and