[WebAssembly] Add support for bitcode archive members

[sbc100]

Summary

This change effects the behaviour of --export-all. Previously --export-all would only
effect symbols that survived GC. Now --export-all will prevent any non-local
symbols from being GCed.

[sbc100]

Use includeInExports() to determine GC roots

[sbc100]

• update test

[ruiu]

LGTM

wasm/Symbols.cpp

101

exported might be a better name?

[sbc100]

• feedback

test/wasm/export-all.ll

 ; RUN: llc -O0 -filetype=obj %s -o %t.o
 
 ; RUN: wasm-ld -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; RUN: wasm-ld --export-all -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=EXPORT
 
 ; RUN: wasm-ld --export-all --no-gc-sections -o %t.wasm %t.o
-; RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=NOGC
+; RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=EXPORT
 
 ; Verify the --export-all flag exports hidden symbols
 
 target triple = "wasm32-unknown-unknown"
 
+define internal void @internal_func() local_unnamed_addr {
+entry:
+  ret void
+}
+
 define hidden void @bar() local_unnamed_addr {
 entry:
   ret void
 }
 
 define hidden void @foo() local_unnamed_addr {
 entry:
   ret void
 }
 
 define hidden void @_start() local_unnamed_addr {
 entry:
   call void @foo()
+  call void @internal_func()
   ret void
 }
 
 ; CHECK:      - Type:            EXPORT
 ; CHECK:         - Name:            _start
 ; CHECK-NOT:     - Name:            bar
 ; CHECK-NOT:     - Name:            foo
+; CHECK-NOT:     - Name:            internal_func
 
 ; EXPORT:     - Type:            EXPORT
 ; EXPORT:        - Name:            _start
-; EXPORT-NOT:    - Name:            bar
+; EXPORT:        - Name:            bar
 ; EXPORT:        - Name:            foo
-
-; NOGC:       - Type:            EXPORT
-; NOGC:        - Name:            _start
-; NOGC:        - Name:            bar
-; NOGC:        - Name:            foo
+; EXPORT-NOT:    - Name:            internal_func

test/wasm/lto/Inputs/archive.ll

+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+define void @f() {
+  ret void
+}

test/wasm/lto/archive.ll

+; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
+; RUN: rm -f %t.a
+; RUN: llvm-ar rcs %t.a %t1.o
+; RUN: llvm-as %s -o %t2.o
+; RUN: wasm-ld %t2.o %t.a -o %t3
+; RUN: obj2yaml %t3 | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+define void @_start() {
+  call void @f()
+  ret void
+}
+
+declare void @f()
+
+; CHECK:         Name:            name
+; CHECK-NEXT:    FunctionNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            __wasm_call_ctors
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Name:            _start
+; CHECK-NEXT:      - Index:           2
+; CHECK-NEXT:        Name:            f

wasm/InputFiles.cpp

void ArchiveFile::addMember(const Archive::Symbol *Sym) {
   LLVM_DEBUG(dbgs() << "loading lazy: " << Sym->getName() << "\n");
   LLVM_DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
 
   MemoryBufferRef MB =
       CHECK(C.getMemoryBufferRef(),
             "could not get the buffer for the member defining symbol " +
                 Sym->getName());
 
-  if (identify_magic(MB.getBuffer()) != file_magic::wasm_object) {
+  InputFile *Obj;
+
+  file_magic Magic = identify_magic(MB.getBuffer());
+  if (Magic == file_magic::wasm_object) {
+    Obj = make<ObjFile>(MB);
+  } else if (Magic == file_magic::bitcode) {
+    Obj = make<BitcodeFile>(MB);
+  } else {
     error("unknown file type: " + MB.getBufferIdentifier());
     return;
   }
 
-  InputFile *Obj = make<ObjFile>(MB);
   Obj->ParentName = ParentName;
   Symtab->addFile(Obj);
 }
 
 static uint8_t mapVisibility(GlobalValue::VisibilityTypes GvVisibility) {
   switch (GvVisibility) {
   case GlobalValue::DefaultVisibility:
     return WASM_SYMBOL_VISIBILITY_DEFAULT;

wasm/LTO.cpp

for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     ++SymNum;
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F;
-    R.VisibleToRegularObj = Config->Relocatable || Sym->IsUsedInRegularObj;
+    R.VisibleToRegularObj = Config->Relocatable || Sym->IsUsedInRegularObj ||
+                            (R.Prevailing && Sym->includeInExports());
     if (R.Prevailing)
       undefine(Sym);
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting objects.

wasm/MarkLive.cpp

if (InputChunk *Chunk = Sym->getChunk())
       Q.push_back(Chunk);
   };
 
   // Add GC root symbols.
   if (!Config->Entry.empty())
     Enqueue(Symtab->find(Config->Entry));
   Enqueue(WasmSym::CallCtors);
 
-  // We export all defined, non-hidden symbols so they are all gc roots too
+  // We need to preserve any exported symbol
   for (Symbol *Sym : Symtab->getSymbols())
-    if (Sym->isDefined() && !Sym->isHidden())
+    if (Sym->includeInExports())
       Enqueue(Sym);
 
   // The ctor functions are all used in the synthetic __wasm_call_ctors
   // function, but since this function is created in-place it doesn't contain
   // relocations which mean we have to manually mark the ctors.
   for (const ObjFile *Obj : Symtab->ObjectFiles) {
     const WasmLinkingData &L = Obj->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions)

wasm/Symbols.h

public:
   void setHidden(bool IsHidden);
 
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t Index);
 
   WasmSymbolType getWasmType() const;
+  bool includeInExports() const;
 
   // True if this symbol was referenced by a regular (non-bitcode) object.
   unsigned IsUsedInRegularObj : 1;
 
 protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F)
       : IsUsedInRegularObj(false), Name(Name), SymbolKind(K), Flags(Flags),
         File(F), Referenced(!Config->GcSections) {}

wasm/Symbols.cpp

void Symbol::setHidden(bool IsHidden) {
   LLVM_DEBUG(dbgs() << "setHidden: " << Name << " -> " << IsHidden << "\n");
   Flags &= ~WASM_SYMBOL_VISIBILITY_MASK;
   if (IsHidden)
     Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
   else
     Flags |= WASM_SYMBOL_VISIBILITY_DEFAULT;
 }
 
+bool Symbol::includeInExports() const {
+  if (!isDefined() || isLocal())
+    return false;
+
+  if (Config->ExportAll)
+    return true;
+
+  return !isHidden();
+}
+
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function->getFunctionIndex();
   assert(FunctionIndex != INVALID_INDEX);
   return FunctionIndex;
 }
 
 void FunctionSymbol::setFunctionIndex(uint32_t Index) {

wasm/Writer.cpp

if (!Config->Relocatable && !Config->ImportMemory)
     Exports.push_back(WasmExport{"memory", WASM_EXTERNAL_MEMORY, 0});
 
   if (!Config->Relocatable && Config->ExportTable)
     Exports.push_back(WasmExport{kFunctionTableName, WASM_EXTERNAL_TABLE, 0});
 
   unsigned FakeGlobalIndex = NumImportedGlobals + InputGlobals.size();
 
   for (Symbol *Sym : Symtab->getSymbols()) {
-    if (!Sym->isDefined())
-      continue;
-    if (Sym->isHidden() && !Config->ExportAll)
-      continue;
-    if (Sym->isLocal())
+    if (!Sym->includeInExports())
       continue;
     if (!Sym->isLive())
       continue;
 
     StringRef Name = Sym->getName();
     WasmExport Export;
     if (auto *F = dyn_cast<DefinedFunction>(Sym)) {
       Export = {Name, WASM_EXTERNAL_FUNCTION, F->getFunctionIndex()};