COFF: Switch to new archive writer interface (D21721).

[ruiu]

LGTM

[pcc]

• Update for changes to D21721

COFF/DriverUtils.cpp

static std::unique_ptr<MemoryBuffer> createEmptyImportLibrary() {
   E.run();
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(Path2, -1, false);
   error(BufOrErr, Twine("Failed to open ") + Path2);
   return MemoryBuffer::getMemBufferCopy((*BufOrErr)->getBuffer());
 }
 
-static std::vector<NewArchiveIterator>
+static std::vector<NewArchiveMember>
 readMembers(const object::Archive &Archive) {
-  std::vector<NewArchiveIterator> V;
+  std::vector<NewArchiveMember> V;
   for (const auto &ChildOrErr : Archive.children()) {
     error(ChildOrErr, "Archive::Child::getName failed");
     const object::Archive::Child C(*ChildOrErr);
-    ErrorOr<StringRef> NameOrErr = C.getName();
-    error(NameOrErr, "Archive::Child::getName failed");
-    V.emplace_back(C, *NameOrErr);
+    std::error_code EC;
+    V.emplace_back(C, /*Deterministic=*/true, EC);
+    error(EC, "NewArchiveMember::NewArchiveMember failed");
   }
   return V;
 }
 
 // This class creates short import files which is described in
 // PE/COFF spec 7. Import Library Format.
 class ShortImportCreator {
 public:
-  ShortImportCreator(object::Archive *A, StringRef S) : Parent(A), DLLName(S) {}
+  ShortImportCreator(StringRef S) : DLLName(S) {}
 
-  NewArchiveIterator create(StringRef Sym, uint16_t Ordinal,
-                            ImportNameType NameType, bool isData) {
+  NewArchiveMember create(StringRef Sym, uint16_t Ordinal,
     size_t ImpSize = DLLName.size() + Sym.size() + 2; // +2 for NULs
-    size_t Size = sizeof(object::ArchiveMemberHeader) +
-                  sizeof(coff_import_header) + ImpSize;
+    size_t Size = sizeof(coff_import_header) + ImpSize;
     char *Buf = Alloc.Allocate<char>(Size);
     memset(Buf, 0, Size);
     char *P = Buf;
 
-    // Write archive member header
-    auto *Hdr = reinterpret_cast<object::ArchiveMemberHeader *>(P);
-    P += sizeof(*Hdr);
-    sprintf(Hdr->Name, "%-12s", "dummy");
-    sprintf(Hdr->LastModified, "%-12d", 0);
-    sprintf(Hdr->UID, "%-6d", 0);
-    sprintf(Hdr->GID, "%-6d", 0);
-    sprintf(Hdr->AccessMode, "%-8d", 0644);
-    sprintf(Hdr->Size, "%-10d", int(sizeof(coff_import_header) + ImpSize));
-
     // Write short import library.
     auto *Imp = reinterpret_cast<coff_import_header *>(P);
     P += sizeof(*Imp);
     Imp->Sig2 = 0xFFFF;
     Imp->Machine = Config->Machine;
     Imp->SizeOfData = ImpSize;
     if (Ordinal > 0)
       Imp->OrdinalHint = Ordinal;
     Imp->TypeInfo = (isData ? IMPORT_DATA : IMPORT_CODE);
     Imp->TypeInfo |= NameType << 2;
 
     // Write symbol name and DLL name.
     memcpy(P, Sym.data(), Sym.size());
     P += Sym.size() + 1;
     memcpy(P, DLLName.data(), DLLName.size());
 
-    std::error_code EC;
-    object::Archive::Child C(Parent, Buf, &EC);
-    assert(!EC && "We created an invalid buffer");
-    return NewArchiveIterator(C, DLLName);
+    return NewArchiveMember(MemoryBufferRef(StringRef(Buf, Size), DLLName));
   }
 
 private:
   BumpPtrAllocator Alloc;
-  object::Archive *Parent;
   StringRef DLLName;
 };
 
 static ImportNameType getNameType(StringRef Sym, StringRef ExtName) {
   if (Sym != ExtName)
     return IMPORT_NAME_UNDECORATE;
   if (Config->Machine == I386 && Sym.startswith("_"))
     return IMPORT_NAME_NOPREFIX;

 // Creates an import library for a DLL. In this function, we first
 // create an empty import library using lib.exe and then adds short
 // import files to that file.
 void writeImportLibrary() {
   std::unique_ptr<MemoryBuffer> Buf = createEmptyImportLibrary();
   std::error_code EC;
   object::Archive Archive(Buf->getMemBufferRef(), EC);
   error(EC, "Error reading an empty import file");
-  std::vector<NewArchiveIterator> Members = readMembers(Archive);
+  std::vector<NewArchiveMember> Members = readMembers(Archive);
 
   std::string DLLName = llvm::sys::path::filename(Config->OutputFile);
-  ShortImportCreator ShortImport(&Archive, DLLName);
+  ShortImportCreator ShortImport(DLLName);
   for (Export &E : Config->Exports) {
     if (E.Private)
       continue;
     if (E.ExtName.empty()) {
       Members.push_back(ShortImport.create(
           E.SymbolName, E.Ordinal, getNameType(E.SymbolName, E.Name), E.Data));
     } else {
       Members.push_back(ShortImport.create(