[WebAssembly] Don't GC constructors from libraries under --whole-archive

[sunfish]

Summary

When --whole-archive is active, treat object files linked from archives
as live, and don't GC their constructors.

[sbc100]

Wow you are fast :) do you prefer this solution over mine?

[sunfish]

Either patch works for me. Yours is shorter :-).

[sunfish]

Abandoned in favor of https://reviews.llvm.org/D89290 .

lld/test/wasm/ctor-no-gc-whole-archive.test

+; Like ctor-gc.test, but uses `--whole-archive` to force the entire archive
+; to be linked in, including the constructors.
+;
+; RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/ctor-ctor.s -o %t.ctor.o
+; RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/ctor-lib.s -o %t.lib.o
+; RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown %p/Inputs/ctor-start.s -o %t.start.o
+; RUN: rm -f %t.lib.a
+; RUN: llvm-ar rcs %t.lib.a %t.lib.o %t.ctor.o
+; RUN: wasm-ld %t.start.o --whole-archive %t.lib.a --no-whole-archive -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; CHECK: Name: test_ctor

lld/wasm/Driver.cpp

case file_magic::archive: {
     SmallString<128> importFile = path;
     path::replace_extension(importFile, ".imports");
     if (fs::exists(importFile))
       readImportFile(importFile.str());
 
     // Handle -whole-archive.
     if (inWholeArchive) {
       for (MemoryBufferRef &m : getArchiveMembers(mbref))
-        files.push_back(createObjectFile(m, path));
+        files.push_back(createObjectFile(m, path, true));
       return;
     }
 
     std::unique_ptr<Archive> file =
         CHECK(Archive::create(mbref), path + ": failed to parse archive");
 
     if (!file->isEmpty() && !file->hasSymbolTable()) {
       error(mbref.getBufferIdentifier() +

lld/wasm/InputFiles.h

 private:
   std::unique_ptr<llvm::object::Archive> file;
   llvm::DenseSet<uint64_t> seen;
 };
 
 // .o file (wasm object file)
 class ObjFile : public InputFile {
 public:
-  explicit ObjFile(MemoryBufferRef m, StringRef archiveName)
+  explicit ObjFile(MemoryBufferRef m, StringRef archiveName, bool inWholeArchive)
       : InputFile(ObjectKind, m) {
     this->archiveName = std::string(archiveName);
 
     // If this isn't part of an archive, it's eagerly linked, so mark it live.
-    if (archiveName.empty())
+    if (archiveName.empty() || inWholeArchive)
       markLive();
   }
   static bool classof(const InputFile *f) { return f->kind() == ObjectKind; }
 
   void parse(bool ignoreComdats = false);
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return wasmObj.get(); }

 public:
   explicit SharedFile(MemoryBufferRef m) : InputFile(SharedKind, m) {}
   static bool classof(const InputFile *f) { return f->kind() == SharedKind; }
 };
 
 // .bc file
 class BitcodeFile : public InputFile {
 public:
-  explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName)
+  explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName, bool inWholeArchive)
       : InputFile(BitcodeKind, m) {
     this->archiveName = std::string(archiveName);
 
     // If this isn't part of an archive, it's eagerly linked, so mark it live.
-    if (archiveName.empty())
+    if (archiveName.empty() || inWholeArchive)
       markLive();
   }
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
 
   void parse();
   std::unique_ptr<llvm::lto::InputFile> obj;
 
   // Set to true once LTO is complete in order prevent further bitcode objects
   // being added.
   static bool doneLTO;
 };
 
 inline bool isBitcode(MemoryBufferRef mb) {
   return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
 }
 
 // Will report a fatal() error if the input buffer is not a valid bitcode
 // or wasm object file.
-InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName = "");
+InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName = "",
+                            bool inWholeArchive = false);
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *file);
 
 } // namespace lld
 
 #endif

lld/wasm/InputFiles.cpp

Optional<MemoryBufferRef> readFile(StringRef path) {
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take MB ownership
 
   if (tar)
     tar->append(relativeToRoot(path), mbref.getBuffer());
   return mbref;
 }
 
 InputFile *createObjectFile(MemoryBufferRef mb,
-                                       StringRef archiveName) {
+                                       StringRef archiveName,
+                                       bool inWholeArchive) {
   file_magic magic = identify_magic(mb.getBuffer());
   if (magic == file_magic::wasm_object) {
     std::unique_ptr<Binary> bin =
         CHECK(createBinary(mb), mb.getBufferIdentifier());
     auto *obj = cast<WasmObjectFile>(bin.get());
     if (obj->isSharedObject())
       return make<SharedFile>(mb);
-    return make<ObjFile>(mb, archiveName);
+    return make<ObjFile>(mb, archiveName, inWholeArchive);
   }
 
   if (magic == file_magic::bitcode)
-    return make<BitcodeFile>(mb, archiveName);
+    return make<BitcodeFile>(mb, archiveName, inWholeArchive);
 
   fatal("unknown file type: " + mb.getBufferIdentifier());
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + toString(this) +
       "\n              Symbols : " + Twine(symbols.size()) +
       "\n     Function Imports : " + Twine(wasmObj->getNumImportedFunctions()) +

lld/wasm/SymbolTable.cpp

if (bitcodeFiles.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   lto.reset(new BitcodeCompiler);
   for (BitcodeFile *f : bitcodeFiles)
     lto->add(*f);
 
   for (StringRef filename : lto->compile()) {
-    auto *obj = make<ObjFile>(MemoryBufferRef(filename, "lto.tmp"), "");
+    auto *obj = make<ObjFile>(MemoryBufferRef(filename, "lto.tmp"), "", false);
     obj->parse(true);
     objectFiles.push_back(obj);
   }
 }
 
 Symbol *SymbolTable::find(StringRef name) {
   auto it = symMap.find(CachedHashStringRef(name));
   if (it == symMap.end() || it->second == -1)