Attempted revert of b3b4cda and 950ae43

[dschuff]

Summary

This reverts commit b3b4cda104068e92b77f18c4e3fc0e0b8f3650e0 and
950ae43091121ea357f735790f4042264cf40728.
("[lld][WebAssembly] Don't GC library objects under --whole-archive" and
"[WebAssembly] GC constructor functions in otherwise unused archive objects").

We are getting more reports of problems from users.

lld/test/wasm/Inputs/ctor-ctor.s

-  .section  .text.def,"",@
-  .globl def
-def:
-  .functype def () -> ()
-  end_function
-
-  .section  .text.test_ctor,"",@
-  .globl test_ctor
-test_ctor:
-  .functype test_ctor () -> ()
-  end_function
-
-  .section  .init_array,"",@
-  .p2align  2
-  .int32 test_ctor

lld/test/wasm/Inputs/ctor-lib.s

-  .section  .text.lib_func,"",@
-  .globl  lib_func
-lib_func:
-  .functype lib_func () -> ()
-  end_function
-
-  .section  .text.unused_lib_func,"",@
-  .globl unused_lib_func
-unused_lib_func:
-  .functype unused_lib_func () -> ()
-  call def
-  end_function
-
-  .functype def () -> ()

lld/test/wasm/Inputs/ctor-setup-call-def.s

-# Like Inputs/ctor-setup.s, except it calls `def` instead of `lib_func`,
-# so it pulls in the .o file containing `ctor`.
-
-  .section  .text._start,"",@
-  .globl  _start
-_start:
-  .functype _start () -> ()
-  end_function
-
-  .section  .text.setup,"",@
-  .globl setup
-setup:
-  .functype setup () -> ()
-  call def
-  end_function
-
-  .section  .init_array,"",@
-  .p2align  2
-  .int32 setup
-
-.functype       def () -> ()

lld/test/wasm/Inputs/ctor-setup.s

-# Like Inputs/ctor-start.s, except it calls `lib_func` from a ctor
-# instead of from `_start`.
-
-  .globl  _start
-_start:
-  .functype _start () -> ()
-  end_function
-
-  .globl  setup
-setup:
-  .functype setup () -> ()
-  call  lib_func
-  end_function
-
-  .section  .init_array,"",@
-  .p2align  2
-  .int32  setup
-
-        .functype       lib_func () -> ()

lld/test/wasm/Inputs/ctor-start.s

-  .globl _start
-_start:
-  .functype _start () -> ()
-  call lib_func
-  end_function
-
-  .functype lib_func () -> ()

lld/test/wasm/ctor-gc-setup.test

-; Like ctor-gc.test, but main object calls a function from its constructor,
-; which shouldn't matter; `ctor` shouldn't be pulled in.
-;
-; 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-setup.s -o %t.setup.o
-; RUN: rm -f %t.lib.a
-; RUN: llvm-ar rcs %t.lib.a %t.lib.o %t.ctor.o
-; RUN: wasm-ld %t.setup.o %t.lib.a -o %t.wasm
-; RUN: obj2yaml %t.wasm | FileCheck %s
-
-; CHECK-NOT: Name: test_ctor

lld/test/wasm/ctor-gc.test

-; Verify that constructors from a .o file which it initially depends on but
-; doesn't ultimately contribute to the final link are not included.
-;
-; 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 %t.lib.a -o %t.wasm
-; RUN: wasm-ld %t.start.o --whole-archive %t.lib.a -o %t2.wasm
-; RUN: obj2yaml %t.wasm | FileCheck %s
-; RUN: obj2yaml %t2.wasm | FileCheck %s -check-prefix=WHOLEARCHIVE
-
-; CHECK-NOT: __wasm_call_ctors
-
-; WHOLEARCHIVE: __wasm_call_ctors

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

-; Like ctor-gc-setup.test, but it calls a different function, so it does pull
-; in the object containing `ctor`, so `ctor` is linked in.
-;
-; 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-setup-call-def.s -o %t.setup-call-def.o
-; RUN: rm -f %t.lib.a
-; RUN: llvm-ar rcs %t.lib.a %t.lib.o %t.ctor.o
-; RUN: wasm-ld %t.setup-call-def.o %t.lib.a -o %t.wasm
-; RUN: obj2yaml %t.wasm | FileCheck %s
-
-; CHECK: Name: test_ctor

lld/wasm/Driver.cpp

void LinkerDriver::addFile(StringRef path) {
   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)) {
-        auto *object = createObjectFile(m, path);
-        // Mark object as live; object members are normally not
-        // live by default but -whole-archive is designed to treat
-        // them as such.
-        object->markLive();
-        files.push_back(object);
-      }
-
+      for (MemoryBufferRef &m : getArchiveMembers(mbref))
+        files.push_back(createObjectFile(m, path));
       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

public:
 
   // An archive file name if this file is created from an archive.
   std::string archiveName;
 
   ArrayRef<Symbol *> getSymbols() const { return symbols; }
 
   MutableArrayRef<Symbol *> getMutableSymbols() { return symbols; }
 
-  // An InputFile is considered live if any of the symbols defined by it
-  // are live.
-  void markLive() { live = true; }
-  bool isLive() const { return live; }
-
 protected:
-  InputFile(Kind k, MemoryBufferRef m)
-      : mb(m), fileKind(k), live(!config->gcSections) {}
+  InputFile(Kind k, MemoryBufferRef m) : mb(m), fileKind(k) {}
 
   void checkArch(llvm::Triple::ArchType arch) const;
 
   MemoryBufferRef mb;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> symbols;
 
 private:
   const Kind fileKind;
-  bool live;
 };
 
 // .a file (ar archive)
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef m) : InputFile(ArchiveKind, m) {}
   static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
 
   void addMember(const llvm::object::Archive::Symbol *sym);
 
   void parse();
 
 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)
       : 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())
-      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(); }
 

 };
 
 // .bc file
 class BitcodeFile : public InputFile {
 public:
   explicit BitcodeFile(MemoryBufferRef m, StringRef archiveName)
       : 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())
-      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.

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) {
+InputFile *createObjectFile(MemoryBufferRef mb,
+                                       StringRef archiveName) {
   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);

lld/wasm/MarkLive.cpp

 namespace {
 
 class MarkLive {
 public:
   void run();
 
 private:
   void enqueue(Symbol *sym);
-  void enqueueInitFunctions(const ObjFile *sym);
   void mark();
   bool isCallCtorsLive();
 
   // A list of chunks to visit.
   SmallVector<InputChunk *, 256> queue;
 };
 
 } // namespace
 
 void MarkLive::enqueue(Symbol *sym) {
   if (!sym || sym->isLive())
     return;
   LLVM_DEBUG(dbgs() << "markLive: " << sym->getName() << "\n");
-
-  InputFile *file = sym->getFile();
-  bool needInitFunctions = file && !file->isLive() && sym->isDefined();
-
   sym->markLive();
-
-  // Mark ctor functions in the object that defines this symbol live.
-  // The ctor functions are all referenced by the synthetic callCtors
-  // function. However, this function does not contain relocations so we
-  // have to manually mark the ctors as live.
-  if (needInitFunctions)
-    enqueueInitFunctions(cast<ObjFile>(file));
-
   if (InputChunk *chunk = sym->getChunk())
     queue.push_back(chunk);
 }
 
-// The ctor functions are all referenced by the synthetic callCtors
-// function.  However, this function does not contain relocations so we
-// have to manually mark the ctors as live.
-void MarkLive::enqueueInitFunctions(const ObjFile *obj) {
-  const WasmLinkingData &l = obj->getWasmObj()->linkingData();
-  for (const WasmInitFunc &f : l.InitFunctions) {
-    auto *initSym = obj->getFunctionSymbol(f.Symbol);
-    if (!initSym->isDiscarded())
-      enqueue(initSym);
-  }
-}
-
 void MarkLive::run() {
   // Add GC root symbols.
   if (!config->entry.empty())
     enqueue(symtab->find(config->entry));
 
   // We need to preserve any no-strip or exported symbol
   for (Symbol *sym : symtab->getSymbols())
     if (sym->isNoStrip() || sym->isExported())
       enqueue(sym);
 
   if (WasmSym::callDtors)
     enqueue(WasmSym::callDtors);
 
-  // Enqueue constructors in objects explicitly live from the command-line.
-  for (const ObjFile *obj : symtab->objectFiles)
-    if (obj->isLive())
-      enqueueInitFunctions(obj);
+  if (WasmSym::initMemory)
+     enqueue(WasmSym::initMemory);
 
   mark();
-
-  // If we have any non-discarded init functions, mark `__wasm_call_ctors` as
-  // live so that we assign it an index and call it.
-  if (isCallCtorsLive())
-    WasmSym::callCtors->markLive();
 }
 
 void MarkLive::mark() {
   // Follow relocations to mark all reachable chunks.
   while (!queue.empty()) {
     InputChunk *c = queue.pop_back_val();
 
     for (const WasmRelocation reloc : c->getRelocations()) {
bool MarkLive::isCallCtorsLive() {
   // `__wasm_apply_relocs`.
   if (config->isPic)
     return true;
 
   // If there are any init functions, mark `__wasm_call_ctors` live so that
   // it can call them.
   for (const ObjFile *file : symtab->objectFiles) {
     const WasmLinkingData &l = file->getWasmObj()->linkingData();
-    for (const WasmInitFunc &f : l.InitFunctions) {
-      auto *sym = file->getFunctionSymbol(f.Symbol);
-      if (!sym->isDiscarded() && sym->isLive())
+    for (const WasmInitFunc &f : l.InitFunctions)
+      if (!file->getFunctionSymbol(f.Symbol)->isDiscarded())
         return true;
-    }
-  }
 
   return false;
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/Symbols.cpp

if (auto *e = dyn_cast<DefinedEvent>(this))
     return e->event->live;
   if (InputChunk *c = getChunk())
     return c->live;
   return referenced;
 }
 
 void Symbol::markLive() {
   assert(!isDiscarded());
-  if (file != NULL)
-    file->markLive();
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     g->global->live = true;
   if (auto *e = dyn_cast<DefinedEvent>(this))
     e->event->live = true;
   if (InputChunk *c = getChunk())
     c->live = true;
   referenced = true;
 }

lld/wasm/Writer.cpp

void Writer::calculateInitFunctions() {
   if (!config->relocatable && !WasmSym::callCtors->isLive())
     return;
 
   for (ObjFile *file : symtab->objectFiles) {
     const WasmLinkingData &l = file->getWasmObj()->linkingData();
     for (const WasmInitFunc &f : l.InitFunctions) {
       FunctionSymbol *sym = file->getFunctionSymbol(f.Symbol);
       // comdat exclusions can cause init functions be discarded.
-      if (sym->isDiscarded() || !sym->isLive())
+      if (sym->isDiscarded())
         continue;
+      assert(sym->isLive());
       if (sym->signature->Params.size() != 0)
         error("constructor functions cannot take arguments: " + toString(*sym));
       LLVM_DEBUG(dbgs() << "initFunctions: " << toString(*sym) << "\n");
       initFunctions.emplace_back(WasmInitEntry{sym, f.Priority});
     }
   }
 
   // Sort in order of priority (lowest first) so that they are called